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