public Task <DataProviderGetRecords <BlogComment> > GetItemsAsync(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) { filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(BlogComment.EntryIdentity), Operator = "==", Value = EntryIdentity }); return(DataProvider.GetRecordsAsync(skip, take, sort, filters)); }
private GridDefinition GetGridModel(int blogCategory) { return(new GridDefinition { ModuleGuid = Module.ModuleGuid, SettingsModuleGuid = Module.PermanentGuid, RecordType = typeof(BrowseItem), AjaxUrl = GetActionUrl(nameof(EntriesBrowse_GridData)), ExtraData = new BrowseItem.ExtraData { BlogCategory = blogCategory }, DirectDataAsync = async(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => { // filter by category if (blogCategory != 0) { filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(BlogEntry.CategoryIdentity), Operator = "==", Value = blogCategory, }); } using (BlogEntryDataProvider entryDP = new BlogEntryDataProvider()) { using (BlogCategoryDataProvider categoryDP = new BlogCategoryDataProvider()) { DataProviderGetRecords <BlogEntry> browseItems = await entryDP.GetItemsAsync(skip, take, sort, filters); return new DataSourceResult { Data = (from s in browseItems.Data select new BrowseItem(Module, categoryDP, s)).ToList <object>(), Total = browseItems.Total }; } } }, }); }
// API // API // API public async Task <UserDefinition> GetItemAsync(int userId) { List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserId), Operator = "==", Value = userId }); return(await GetItemAsync(filters)); }
public async Task <UserDefinition> GetItemByEmailAsync(string email) { List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(UserDefinition.Email), Operator = "==", Value = email }); return(await GetItemAsync(filters)); }
public async Task <bool> RemoveAllCommentsAsync() { List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(BlogComment.EntryIdentity), Operator = "==", Value = EntryIdentity }); await DataProvider.RemoveRecordsAsync(filters); return(true); }
/// <summary> /// Removes all login provider and key info for a specific user. /// </summary> /// <param name="userId"></param> /// <returns></returns> public async Task <bool> RemoveItemAsync(int userId) { List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserId), Operator = "==", Value = userId }); return(await RemoveItemsAsync(filters) > 0); }
public async Task <ActionResult> UsersAdd_Partial(AddModel model) { if (!ModelState.IsValid) { return(PartialView(model)); } using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) { LoginConfigData config = await LoginConfigDataProvider.GetConfigAsync(); switch (config.RegistrationType) { default: case RegistrationTypeEnum.NameAndEmail: { // Email == model.Email List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(UserDefinition.Email), Operator = "==", Value = model.Email, }); UserDefinition userExists = await dataProvider.GetItemAsync(filters); if (userExists != null) { ModelState.AddModelError(nameof(model.Email), this.__ResStr("emailUsed", "An account using email address {0} already exists.", model.Email)); return(PartialView(model)); } break; } case RegistrationTypeEnum.EmailOnly: model.UserName = model.Email; break; case RegistrationTypeEnum.NameOnly: model.UserName = model.Email; break; } UserDefinition user = model.GetData(); string hashedNewPassword; #if MVC6 IPasswordHasher <UserDefinition> passwordHasher = (IPasswordHasher <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(IPasswordHasher <UserDefinition>)); hashedNewPassword = passwordHasher.HashPassword(user, model.Password); #else UserManager <UserDefinition> userManager = Managers.GetUserManager(); hashedNewPassword = userManager.PasswordHasher.HashPassword(model.Password); #endif user.PasswordPlainText = config.SavePlainTextPassword ? model.Password : null; user.PasswordHash = hashedNewPassword; if (!await dataProvider.AddItemAsync(user)) { throw new Error(this.__ResStr("alreadyExists", "A user named \"{0}\" already exists."), model.UserName); } return(FormProcessed(model, this.__ResStr("okSaved", "New user saved"), OnPopupClose: OnPopupCloseEnum.ReloadModule)); } }
public async Task UpdatePasswordExpiration(List <string> errorList) { long ticks = WebConfigHelper.GetValue <long>(YetaWF.Modules.Identity.Controllers.AreaRegistration.CurrentPackage.AreaName, "PasswordRenewal", new TimeSpan(0, 0, 0).Ticks); // 0 = indefinitely if (ticks <= 0) { return; // nothing to do } TimeSpan interval = new TimeSpan(ticks); // renewal interval DateTime oldestDate = DateTime.UtcNow.Subtract(interval); using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) { int offset = 0; const int CHUNK = 50; for (;;) { List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserStatus), Operator = "==", Value = UserStatusEnum.Approved }); filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.NeedsNewPassword), Operator = "==", Value = false }); DataProviderGetRecords <UserDefinition> usersInfo = await userDP.GetItemsAsync(offset, CHUNK, null, filters); if (usersInfo.Data.Count == 0) { return; } foreach (UserDefinition user in usersInfo.Data) { bool forceUpdate = false; if (user.LastPasswordChangedDate != null && user.LastPasswordChangedDate < oldestDate) { forceUpdate = true; } else if (user.LastPasswordChangedDate == null && user.Created < oldestDate) { forceUpdate = true; } if (forceUpdate) { user.NeedsNewPassword = true; await userDP.UpdateItemAsync(user); Logging.AddLog($"Updated {user.Id} {user.UserName} - requires password"); } } offset += CHUNK; System.Threading.Thread.Sleep(5 * 1000); // wait some 5 seconds } } }
public async Task <Connection> GetEntryAsync(string name) { List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = "Name", Operator = "==", Value = name }); DataProviderGetRecords <Connection> conns = await GetItemsAsync(0, 1, null, filters); return(conns.Data.FirstOrDefault()); }
private async Task <SerializableList <Guid> > UpdatePageGuidsAsync(Guid unifiedSetGuid, List <string> pageList) { pageList = pageList != null ? pageList : new List <string>(); SerializableList <Guid> pageGuids = new SerializableList <Guid>(); using (PageDefinitionDataProvider pageDP = new PageDefinitionDataProvider()) { // Get all pages that are currently part of the unified page set List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(PageDefinition.UnifiedSetGuid), Operator = "==", Value = unifiedSetGuid }); DataProviderGetRecords <PageDefinition> pageDefs = await pageDP.GetItemsAsync(0, 0, null, filters); // translate page list to guid list (preserving order) foreach (string page in pageList) { PageDefinition pageDef = await pageDP.LoadPageDefinitionAsync(page); if (pageDef != null) { pageGuids.Add(pageDef.PageGuid); // check if it's already in the list PageDefinition pageFound = (from p in pageDefs.Data where p.Url == page select p).FirstOrDefault(); if (pageFound == null) { // page not in list, add it pageDef.UnifiedSetGuid = unifiedSetGuid; await pageDP.SavePageDefinitionAsync(pageDef); } else if (pageFound.UnifiedSetGuid != unifiedSetGuid) { // page in list but with the wrong unifiedSetGuid pageDef.UnifiedSetGuid = unifiedSetGuid; await pageDP.SavePageDefinitionAsync(pageDef); pageDefs.Data.Remove(pageFound); } else { // page already in list pageDefs.Data.Remove(pageFound); } } } // remove all remaining pages from unified page set, they're no longer in the list foreach (PageDefinition pageDef in pageDefs.Data) { pageDef.UnifiedSetGuid = null; await pageDP.SavePageDefinitionAsync(pageDef); } } return(pageGuids); }
// API // API // API public async Task <UserDefinition> GetSuperuserAsync() { if (!SuperuserAvailable) { return(null); } List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserId), Operator = "==", Value = SuperuserDefinitionDataProvider.SuperUserId }); return(await GetItemAsync(filters)); }
public async Task <bool> HasPendingRestartAsync() { List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(AuditInfo.Created), Operator = ">=", Value = YetaWF.Core.Support.Startup.MultiInstanceStartTime }); filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(AuditInfo.RequiresRestart), Operator = "==", Value = true }); DataProviderGetRecords <AuditInfo> info = await DataProvider.GetRecordsAsync(0, 1, null, filters); return(info.Total > 0); }
private List <DataProviderFilterInfo> FixFilters(List <DataProviderFilterInfo> filters) { if (filters == null) { return(filters); } List <DataProviderFilterInfo> newFilters = new List <DataProviderFilterInfo>(); DataProviderFilterInfo.NormalizeFilters(typeof(SchedulerItemData), filters); foreach (DataProviderFilterInfo f in filters) { if (f.Field == "IsRunning") { bool val; if (f.Value.GetType() == typeof(bool)) { val = (bool)f.Value; } else { throw new InternalError("Unexpected value type in filter for IsRunning"); } if (f.Operator == "==") { // nothing } else if (f.Operator == "!=") { val = !val; } else { throw new InternalError("Unexpected operator in filter for IsRunning"); } newFilters.Add(new DataProviderFilterInfo { Field = nameof(SchedulerItemData.Next), Operator = val ? ">=" : "<", Value = DateTime.MaxValue }); } else if (f.Filters != null) { f.Filters = FixFilters(f.Filters); newFilters.Add(f); } else { newFilters.Add(f); } } return(newFilters); }
private async Task <ExtUserInfo> GetUserInfo(LoginConfigData config) { ExtUserInfo info = new ExtUserInfo(); SignInManager <UserDefinition> _signinManager = (SignInManager <UserDefinition>)YetaWFManager.ServiceProvider.GetService(typeof(SignInManager <UserDefinition>)); ExternalLoginInfo loginInfo = await _signinManager.GetExternalLoginInfoAsync(); if (loginInfo == null) { Logging.AddErrorLog("AuthenticationManager.GetExternalLoginInfoAsync() returned null"); throw new Error(this.__ResStr("noExtLogin", "No external login has been processed")); } info.LoginInfo = loginInfo; info.Email = loginInfo.Principal.FindFirstValue(ClaimTypes.Email); info.Name = loginInfo.Principal.FindFirstValue(ClaimTypes.Name); info.LoginProvider = loginInfo.LoginProvider; info.LoginProviderDisplay = loginInfo.ProviderDisplayName; // Check whether this is an invited user using (UserDefinitionDataProvider dataProvider = new UserDefinitionDataProvider()) { List <DataProviderFilterInfo> filters = null; switch (config.RegistrationType) { default: case RegistrationTypeEnum.NameAndEmail: filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserName), Operator = "==", Value = info.Name, }); filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.Email), Operator = "==", Value = info.Email, }); break; case RegistrationTypeEnum.EmailOnly: filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.Email), Operator = "==", Value = info.Email, }); break; case RegistrationTypeEnum.NameOnly: filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserName), Operator = "==", Value = info.Name, }); break; } info.ExistingUser = await dataProvider.GetItemAsync(filters); } return(info); }
private async Task <string> UpdateMessage(EditModel model, int toUserId, bool NeedUser = false) { if (!NeedUser && toUserId == 0) { return(null); } using (MessagingDataProvider msgDP = new MessagingDataProvider()) { string toUser = await Resource.ResourceAccess.GetUserNameAsync(model.ToUserId); if (string.IsNullOrWhiteSpace(toUser)) { throw new Error(this.__ResStr("noUser", "User id {0} doesn't exist", model.ToUserId)); } List <DataProviderFilterInfo> filters = null; List <DataProviderFilterInfo> subFilters = null; subFilters = DataProviderFilterInfo.Join(subFilters, new DataProviderFilterInfo { Field = "FromUser", Operator = "==", Value = Manager.UserId }); subFilters = DataProviderFilterInfo.Join(subFilters, new DataProviderFilterInfo { Field = "ToUser", Operator = "==", Value = toUserId }); filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Logic = "||", Filters = subFilters }); subFilters = null; subFilters = DataProviderFilterInfo.Join(subFilters, new DataProviderFilterInfo { Field = "ToUser", Operator = "==", Value = Manager.UserId }); subFilters = DataProviderFilterInfo.Join(subFilters, new DataProviderFilterInfo { Field = "FromUser", Operator = "==", Value = toUserId }); filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Logic = "||", Filters = subFilters }); List <DataProviderSortInfo> sorts = null; sorts = DataProviderSortInfo.Join(sorts, new DataProviderSortInfo { Field = "Sent", Order = DataProviderSortInfo.SortDirection.Descending }); DataProviderGetRecords <Message> recs = await msgDP.GetItemsAsync(0, model.MaxMessages, sorts, filters); model.MessageData.Messages = recs.Data; model.MessageData.Messages.Reverse(); model.MessageData.FromUser = Manager.UserName; model.MessageData.ToUser = toUser; model.MessageData.TotalMessages = recs.Total; return(toUser); } }
internal async Task <SearchDataUrl> GetItemByUrlAsync(string pageUrl) { if (!SearchDataProvider.IsUsable) { return(null); } List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(SearchDataUrl.PageUrl), Operator = "==", Value = pageUrl }); SearchDataUrl searchUrl = await DataProvider.GetOneRecordAsync(filters); return(searchUrl); }
public async Task RemoveAsync(List <string> errorList) { AuditConfigData config = await AuditConfigDataProvider.GetConfigAsync(); DateTime oldest = DateTime.UtcNow.AddDays(-config.Days); using (AuditInfoDataProvider auditDP = new AuditInfoDataProvider()) { List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(AuditInfo.Created), Operator = "<", Value = oldest }); int removed = await auditDP.RemoveItemsAsync(filters); errorList.Add(string.Format("{0} records removed from audit data", removed)); } }
/// <summary> /// Return the external login provider user for the specified user id. /// </summary> /// <param name="userId"></param> /// <returns>The name of the external login provider. null is returned if no external login provider is used.</returns> public async Task <string> GetExternalLoginProviderAsync(int userId) { List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserId), Operator = "==", Value = userId }); DataProviderGetRecords <LoginInfo> logInfo = await GetItemsAsync(0, 0, null, filters); if (logInfo.Data.Count > 0) { return(logInfo.Data[0].LoginProvider); } return(null); }
public async Task RemoveAsync(List <string> errorList) { VisitorsConfigData config = await VisitorsConfigDataProvider.GetConfigAsync(); DateTime oldest = DateTime.UtcNow.AddDays(-config.Days); using (VisitorEntryDataProvider visitorEntryDP = new VisitorEntryDataProvider()) { List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(VisitorEntry.AccessDateTime), Operator = "<", Value = oldest }); int removed = await visitorEntryDP.RemoveItemsAsync(filters); errorList.Add(string.Format("{0} records removed from visitor data", removed)); } }
public new async Task <int> RemoveRecordsAsync(List <DataProviderFilterInfo> filters) { if (filters != null && filters.Count == 1) { DataProviderFilterInfo f = filters.First(); int entryIdentity = GetEntryIdentity(); if (f.Field == "EntryIdentity" && f.Operator == "==" && entryIdentity.CompareTo(f.Value) == 0) { await FileSystem.FileSystemProvider.DeleteDirectoryAsync(GetCommentFolder(entryIdentity)); return(1); } } return(await base.RemoveRecordsAsync(filters)); }
public async Task RemoveAsync(List <string> errorList) { LoggingConfigData config = await LoggingConfigDataProvider.GetConfigAsync(); DateTime oldest = DateTime.UtcNow.AddDays(-config.Days); using (LogRecordDataProvider logDP = LogRecordDataProvider.GetLogRecordDataProvider()) { List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(LogRecord.TimeStamp), Operator = "<", Value = oldest }); int removed = await logDP.RemoveItemsAsync(filters); errorList.Add(string.Format("{0} records removed from log data", removed)); } }
public async Task AddGeoLocationAsync(List <string> errorList) { using (VisitorEntryDataProvider visitorEntryDP = new VisitorEntryDataProvider()) { DateTime startTime = DateTime.UtcNow; int overall = 0; List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(VisitorEntry.ContinentCode), Operator = "==", Value = VisitorEntry.Unknown }); filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(VisitorEntry.AccessDateTime), Operator = "<", Value = startTime }); GeoLocation geoLocation = new GeoLocation(); int maxRequest = geoLocation.GetRemainingRequests(); for (; maxRequest > 0; --maxRequest) { DataProviderGetRecords <VisitorEntry> list = await visitorEntryDP.GetItemsAsync(0, 1, null, filters); if (list.Data.Count == 0) { break; } VisitorEntry geoData = list.Data.First(); GeoLocation.UserInfo userInfo = await geoLocation.GetUserInfoAsync(geoData.IPAddress); if (!string.IsNullOrWhiteSpace(userInfo.ContinentCode)) { geoData.City = userInfo.City; geoData.ContinentCode = userInfo.ContinentCode; geoData.CountryCode = userInfo.CountryCode; geoData.RegionCode = userInfo.RegionCode; } else { geoData.City = ""; geoData.ContinentCode = ""; geoData.CountryCode = ""; geoData.RegionCode = ""; } await visitorEntryDP.UpdateSameIPAddressesAsync(geoData); ++overall; } Logging.AddLog($"Updated {overall} visitor entries"); } }
public async Task RemoveOldItemsAsync(DateTime searchStarted) { if (!IsUsable) { return; } using (ILockObject lockObject = await YetaWF.Core.IO.Caching.LockProvider.LockResourceAsync($"{AreaRegistration.CurrentPackage.AreaName}_{nameof(SearchDataProvider)}")) { List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(SearchData.DateAdded), Operator = "<", Value = searchStarted }); await RemoveItemsAsync(filters); await RemoveUnusedUrlsAsync(); await lockObject.UnlockAsync(); } }
private GridDefinition GetGridModel() { return(new GridDefinition { SizeStyle = GridDefinition.SizeStyleEnum.SizeToFit, ModuleGuid = Module.ModuleGuid, //SettingsModuleGuid = Module.PermanentGuid, RecordType = typeof(BrowseItem), AjaxUrl = GetActionUrl(nameof(BrowseVoiceMails_GridData)), DirectDataAsync = async(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => { List <string> extensions = new List <string>(); if (!Manager.HasSuperUserRole) { using (ExtensionEntryDataProvider extDP = new ExtensionEntryDataProvider()) { extensions = await extDP.GetExtensionsForUserAsync(Manager.UserId); } if (extensions.Count == 0) { throw new Error(this.__ResStr("noInbox", "No extension defined for the current user")); } } DisplayVoiceMailModule dispMod = (DisplayVoiceMailModule)await ModuleDefinition.LoadAsync(ModuleDefinition.GetPermanentGuid(typeof(DisplayVoiceMailModule))); using (VoiceMailDataProvider dataProvider = new VoiceMailDataProvider()) { List <DataProviderFilterInfo> extFilters = null; foreach (string extension in extensions) { extFilters = DataProviderFilterInfo.Join(extFilters, new DataProviderFilterInfo { Field = nameof(ExtensionEntry.Extension), Operator = "==", Value = extension }, SimpleLogic: "||"); } if (extFilters != null) { filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Filters = extFilters, Logic = "||" }); } DataProviderGetRecords <VoiceMailData> browseItems = await dataProvider.GetItemsAsync(skip, take, sort, filters); return new DataSourceResult { Data = (from s in browseItems.Data select new BrowseItem(Module, dispMod, s)).ToList <object>(), Total = browseItems.Total }; } }, }); }
public async Task <bool> RemoveEntriesAsync(int categoryIdentity) { // TODO: This could be optimized for SQL using joins %%%%%%%%%%%%%%%%%%% // remove all entries for this category List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(BlogEntry.CategoryIdentity), Operator = "==", Value = categoryIdentity }); DataProviderGetRecords <BlogEntry> data = await GetItemsAsync(0, 0, null, filters); foreach (BlogEntry entry in data.Data) { // remove all comments using (BlogCommentDataProvider commentDP = new BlogCommentDataProvider(entry.Identity)) { await commentDP.RemoveAllCommentsAsync(); } } return(true); }
private async Task RemoveGuidAsync(Guid unifiedSetGuid) { using (PageDefinitionDataProvider pageDP = new PageDefinitionDataProvider()) { // Get all pages that are part of the unified page set List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(PageDefinition.UnifiedSetGuid), Operator = "==", Value = unifiedSetGuid }); DataProviderGetRecords <PageDefinition> pageDefs = await pageDP.GetItemsAsync(0, 0, null, filters); // remove all pages from unified page set if they're not within the page list foreach (PageDefinition pageDef in pageDefs.Data) { pageDef.UnifiedSetGuid = null; await pageDP.SavePageDefinitionAsync(pageDef); } } }
public async Task <List <string> > GetOnlineUsers() { YetaWFManager manager = await this.SetupSignalRAsync(); using (ConnectionDataProvider connDP = new ConnectionDataProvider()) { //%%%%%%%%%%%%%%%%%%% limit scope to friend users List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = "Name", Operator = "!=", Value = null }); List <DataProviderSortInfo> sorts = null; sorts = DataProviderSortInfo.Join(sorts, new DataProviderSortInfo { Field = "Name", Order = DataProviderSortInfo.SortDirection.Ascending }); DataProviderGetRecords <Connection> conns = await connDP.GetItemsAsync(0, 0, sorts, filters); return((from c in conns.Data select c.Name).Distinct().ToList()); } }
internal async Task <SearchData> GetItemWithUrlAsync(int searchDataId) { if (!IsUsable) { return(null); } using (SearchDataUrlDataProvider searchUrlDP = new SearchDataUrlDataProvider()) { List <DataProviderFilterInfo> filters = null; filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo { Field = nameof(SearchData.SearchDataId), Operator = "==", Value = searchDataId }); List <JoinData> joins = new List <JoinData> { new JoinData { MainDP = this, JoinDP = searchUrlDP, MainColumn = nameof(SearchDataUrl.SearchDataUrlId), JoinColumn = nameof(SearchData.SearchDataUrlId) }, }; return(await DataProvider.GetOneRecordAsync(filters, Joins : joins)); } }
internal async Task <SearchResultsInfo> ParseAsync(string searchTerms, int maxResults, string languageId, bool haveUser, List <DataProviderFilterInfo> extraFilters = null) { using (SearchDataProvider searchDP = new SearchDataProvider()) { bool haveMore = false; extraFilters = DataProviderFilterInfo.Join(extraFilters, new DataProviderFilterInfo { Field = nameof(SearchData.Language), Operator = "==", Value = languageId }); if (haveUser) { extraFilters = DataProviderFilterInfo.Join(extraFilters, new DataProviderFilterInfo { Field = nameof(SearchData.AllowAnyUser), Operator = "==", Value = true }); } else { extraFilters = DataProviderFilterInfo.Join(extraFilters, new DataProviderFilterInfo { Field = nameof(SearchData.AllowAnonymous), Operator = "==", Value = true }); } string s = searchTerms; BuildNodesInfo urls = await BuildNodesAsync(searchDP, s, languageId, haveUser, extraFilters); List <DataProvider.SearchResult> results = (from u in urls.Data group u by u.SearchDataUrlId into g select new SearchResult { Count = g.Sum(x => x.Count), PageUrl = g.Select(m => m.PageUrl).FirstOrDefault(), DateCreated = g.Select(m => m.DatePageCreated).FirstOrDefault(), DateUpdated = g.Select(m => m.DatePageUpdated).FirstOrDefault(), Description = g.Select(m => m.PageTitle).FirstOrDefault(), PageSummary = g.Select(m => m.PageSummary).FirstOrDefault(), PageSecurity = g.Select(m => m.PageSecurity).FirstOrDefault(), CustomData = g.Select(m => m.CustomData).FirstOrDefault(), }).OrderByDescending(m => m.Count).Take(maxResults + 1).ToList(); haveMore = (results.Count >= maxResults); return(new Search.DataProvider.SearchResultDataProvider.SearchResultsInfo { Data = results, HaveMore = haveMore, }); } }
private async Task <UpdateStatusEnum> UpdateItemAsync(string originalName, UserDefinition data) { if (string.Compare(originalName, SuperUserName, true) == 0) { if (data.UserName != originalName) { throw new Error(this.__ResStr("cantRenameSuper", "The user \"{0}\" can't be renamed.", data.UserName)); } // we allow status change even for a superuser (mainly to support login failures with automatic suspension) //if (data.UserStatus != UserStatusEnum.Approved) // throw new Error(this.__ResStr("cantChangeStatusSuper", "The user \"{0}\" must remain an approved user. That's the only one that can bail you out when the entire site is broken.", data.UserName)); } if (data.UserId != SuperuserDefinitionDataProvider.SuperUserId || string.Compare(data.UserName, SuperUserName, true) != 0) { throw new Error(this.__ResStr("cantUpdateSuper", "Wrong user id or user name - Can't update as superuser")); } UpdateStatusEnum result; UserDefinition origSuperuser;// need to get current superuser because user may have changed the name through Appsettings.json Package package = YetaWF.Modules.Identity.Controllers.AreaRegistration.CurrentPackage; using (ILockObject lockObject = await YetaWF.Core.IO.Caching.LockProvider.LockResourceAsync($"{package.AreaName}.{nameof(SuperuserDefinitionDataProvider)}_{originalName}")) { List <DataProviderFilterInfo> filters = DataProviderFilterInfo.Join(null, new DataProviderFilterInfo { Field = nameof(UserDefinition.UserId), Operator = "==", Value = SuperuserDefinitionDataProvider.SuperUserId }); origSuperuser = await DataProvider.GetOneRecordAsync(filters); data.RolesList = new SerializableList <Role> { new Role { RoleId = Resource.ResourceAccess.GetSuperuserRoleId() } }; result = await DataProvider.UpdateAsync(origSuperuser.UserName, data.UserName, data); } await Auditing.AddAuditAsync($"{nameof(SuperuserDefinitionDataProvider)}.{nameof(UpdateItemAsync)}", data.UserName, Guid.Empty, "Update Superuser", DataBefore : origSuperuser, DataAfter : data ); return(result); }