private GridDefinition GetGridModel()
{
return(new GridDefinition {
ModuleGuid = Module.ModuleGuid,
SettingsModuleGuid = Module.PermanentGuid,
RecordType = typeof(BrowseItem),
AjaxUrl = GetActionUrl(nameof(CacheInfo_GridData)),
SortFilterStaticData = (List <object> data, int skip, int take, List <DataProviderSortInfo> sorts, List <DataProviderFilterInfo> filters) => {
DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(data, skip, take, sorts, filters);
return new DataSourceResult {
Data = recs.Data.ToList <object>(),
Total = recs.Total,
};
},
DirectDataAsync = (int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => {
DataProviderGetRecords <BrowseItem> items = DataProviderImpl <BrowseItem> .GetRecords(GetAllItems(), skip, take, sort, filters);
foreach (BrowseItem item in items.Data)
{
item.Value = item.Value.TruncateWithEllipse(100);
}
DataSourceResult data = new DataSourceResult {
Data = items.Data.ToList <object>(),
Total = items.Total,
};
return Task.FromResult(data);
},
});
}
public async Task <DataProviderGetRecords <RoleDefinition> > GetItemsAsync(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters)
{
DataProviderGetRecords <RoleDefinition> list = await DataProvider.GetRecordsAsync(skip, take, sort, filters);
list.Data.Insert(0, MakeSuperuserRole());
return(list);
}
/// <summary>
/// Called by the framework when the component needs to be rendered as HTML.
/// </summary>
/// <param name="model">The model being rendered by the component.</param>
/// <returns>The component rendered as HTML.</returns>
public async Task <string> RenderAsync(int model)
{
if (Sites == null)
{
Dictionary <int, StringTT> sites = new Dictionary <int, StringTT>();
DataProviderGetRecords <SiteDefinition> recs = await SiteDefinition.GetSitesAsync(0, 0, null, null);
foreach (SiteDefinition site in recs.Data)
{
sites.Add(site.Identity,
new StringTT {
Text = site.Identity.ToString(),
Tooltip = site.SiteDomain,
}
);
}
Sites = sites;
}
StringTT stringTT;
if (Sites.ContainsKey(model))
{
stringTT = Sites[model];
}
else
{
stringTT = new StringTT {
Text = __ResStr("none", "(none)"),
Tooltip = __ResStr("noneTT", "")
};
}
return(await StringTTDisplayComponent.RenderStringTTAsync(this, stringTT, "yt_siteid"));
}
// IINSTALLABLEMODEL
// IINSTALLABLEMODEL
// IINSTALLABLEMODEL
public new async Task LocalizeModelAsync(string language, Func <string, bool> isHtml, Func <List <string>, Task <List <string> > > translateStringsAsync, Func <string, Task <string> > translateComplexStringAsync)
{
const int RECORDS = 20;
for (int offset = 0; ;)
{
DataProviderGetRecords <MenuInfo> data = await DataProvider.GetRecordsAsync(offset, RECORDS, null, null);
if (data.Data.Count == 0)
{
break;
}
bool changed = false;
foreach (MenuInfo menu in data.Data)
{
changed = await TranslateMenuListAsync(menu.Menu, language, (s) => false, translateStringsAsync, translateComplexStringAsync);
if (changed)
{
UpdateStatusEnum status = await UpdateItemAsync(menu);
if (status != UpdateStatusEnum.OK)
{
throw new InternalError($"Update failed for type {typeof(MenuInfo).FullName} ({status})");
}
}
}
offset += data.Data.Count;
if (offset >= data.Total)
{
break;
}
}
}
private GridDefinition GetGridModel()
{
return(new GridDefinition {
InitialPageSize = 20,
ModuleGuid = Module.ModuleGuid,
SettingsModuleGuid = Module.PermanentGuid,
RecordType = typeof(BrowseItem),
AjaxUrl = GetActionUrl(nameof(StaticPagesBrowse_GridData)),
SortFilterStaticData = (List <object> data, int skip, int take, List <DataProviderSortInfo> sorts, List <DataProviderFilterInfo> filters) => {
DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(data, skip, take, sorts, filters);
foreach (BrowseItem r in recs.Data)
{
r.Module = Module;
}
return new DataSourceResult {
Data = recs.Data.ToList <object>(),
Total = recs.Total,
};
},
DirectDataAsync = async(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => {
List <BrowseItem> items = (from k in await Manager.StaticPageManager.GetSiteStaticPagesAsync() select new BrowseItem(Module, k)).ToList();
int total = items.Count;
DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(items, skip, take, sort, filters);
DataSourceResult data = new DataSourceResult {
Data = recs.Data.ToList <object>(),
Total = total
};
return data;
},
});
}
private async Task <object> GetCalculatedPropertyAsync(string name, object obj)
{
BlogEntry entry = (BlogEntry)obj;
if (name == "CommentsUnapproved")
{
using (DataProvider.BlogCommentDataProvider commentDP = new DataProvider.BlogCommentDataProvider(entry.Identity)) {
List <DataProviderFilterInfo> filters = new List <DataProviderFilterInfo>()
{
new DataProviderFilterInfo {
Field = nameof(BlogComment.Approved), Operator = "==", Value = false,
},
};
DataProviderGetRecords <BlogComment> commentsUnapproved = await commentDP.GetItemsAsync(0, 0, null, filters);
entry.CommentsUnapproved = commentsUnapproved.Total;
return(obj);
}
}
else if (name == "Comments")
{
using (DataProvider.BlogCommentDataProvider commentDP = new DataProvider.BlogCommentDataProvider(entry.Identity)) {
DataProviderGetRecords <BlogComment> comments = await commentDP.GetItemsAsync(0, 0, null, null);
entry.Comments = comments.Total;
return(obj);
}
}
else
{
throw new InternalError("Unexpected property {0}", name);
}
}
public async Task <DataProviderGetRecords <Authorization> > GetItemsAsync(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters)
{
// get all defined authorizations
DataProviderGetRecords <Authorization> list = await DataProvider.GetRecordsAsync(0, 0, null, filters);
foreach (Authorization l in list.Data)
{
l.CanDelete = true;
}
// get all AuthorizationResource items
using (RoleDefinitionDataProvider roleDP = new RoleDefinitionDataProvider(SiteIdentity)) {
AuthorizationResourceDataProvider authResDP = new AuthorizationResourceDataProvider();
DataProviderGetRecords <ResourceAttribute> resAttrs = authResDP.GetItems();
// merge in AuthorizationResource items
foreach (ResourceAttribute resAttr in resAttrs.Data)
{
Authorization auth = (from l in list.Data where l.ResourceName == resAttr.Name select l).FirstOrDefault();
if (auth == null)
{
auth = GetFromAuthorizationResource(roleDP, resAttr);
list.Data.Add(auth);
}
}
}
return(DataProviderImpl <Authorization> .GetRecords(list.Data, skip, take, sort, filters));
}
public async Task AddDataAsync()
{
DataProviderGetRecords <SiteDefinition> info = await SiteDefinition.GetSitesAsync(0, 0, null, null);
SiteDomain_List = (from s in info.Data orderby s.SiteDomain select new SelectionItem <string>()
{
Text = s.SiteDomain,
Value = s.SiteDomain,
Tooltip = this.__ResStr("switchSite", "Switch to site \"{0}\"", s.SiteDomain),
}).ToList();
SiteDomain = Manager.CurrentSite.SiteDomain;
ControlPanelConfigData config = await ControlPanelConfigDataProvider.GetConfigAsync();
UserId_List = config.Users;
UserId = Manager.UserId;
int superuserRole = Resource.ResourceAccess.GetSuperuserRoleId();
if (Manager.UserRoles != null && Manager.UserRoles.Contains(superuserRole))
{
SuperuserCurrent = true;// the current user is a superuser
}
else if (Manager.HasSuperUserRole)
{
SuperuserStillActive = true;
}
else
{
SuperuserStillActive = false;
}
}
// IINSTALLABLEMODEL2
// IINSTALLABLEMODEL2
// IINSTALLABLEMODEL2
public async Task <bool> UpgradeModelAsync(List <string> errorList, string lastSeenVersion)
{
// Convert 2.7.0 (and older) data and add TimeSpan
if (Package.CompareVersion(lastSeenVersion, AreaRegistration.CurrentPackage.Version) < 0 &&
Package.CompareVersion(lastSeenVersion, "2.7.0") <= 0)
{
using (SchedulerDataProvider schedDP = new SchedulerDataProvider()) {
const int chunk = 100;
int skip = 0;
for (; ; skip += chunk)
{
DataProviderGetRecords <SchedulerItemData> list = await schedDP.GetItemsAsync(skip, chunk, null, null);
if (list.Data.Count <= 0)
{
break;
}
foreach (SchedulerItemData l in list.Data)
{
l.TimeSpan = l.Frequency.TimeSpan;
await UpdateItemAsync(l.Name, l);
}
}
}
}
return(true);
}
private GridDefinition GetGridModel()
{
return(new GridDefinition {
ModuleGuid = Module.ModuleGuid,
SettingsModuleGuid = Module.PermanentGuid,
InitialPageSize = 20,
RecordType = typeof(PageItem),
AjaxUrl = GetActionUrl(nameof(PagesBrowse_GridData)),
DirectDataAsync = async(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => {
// page editing services
ModuleDefinition pageSettings = await ModuleDefinition.LoadAsync(Manager.CurrentSite.PageEditingServices, AllowNone : true);
//if (pageSettings == null)
// throw new InternalError("No page edit services available - no module has been defined in Site Properties");
using (PageDefinitionDataProvider dataProvider = new PageDefinitionDataProvider()) {
DataProviderGetRecords <PageDefinition> pages = await dataProvider.GetItemsAsync(skip, take, sort, filters);
return new DataSourceResult {
Data = (from s in pages.Data select new PageItem(Module, s, pageSettings)).ToList <object>(),
Total = pages.Total
};
}
},
});
}
public async Task <ActionResult> UpdateAdminAndEditorAuthorization()
{
using (PageDefinitionDataProvider pageDP = new PageDefinitionDataProvider()) {
int adminRole = Resource.ResourceAccess.GetAdministratorRoleId();
int editorRole = Resource.ResourceAccess.GetEditorRoleId();
DataProviderGetRecords <PageDefinition> pages = await pageDP.GetItemsAsync(0, 0, null, null);
foreach (PageDefinition genericPage in pages.Data)
{
PageDefinition page = await PageDefinition.LoadAsync(genericPage.PageGuid);
if (page != null)
{
PageDefinition.AllowedRole role;
while ((role = PageDefinition.AllowedRole.Find(page.AllowedRoles, adminRole)) != null)
{
page.AllowedRoles.Remove(role);
}
page.AllowedRoles.Add(new PageDefinition.AllowedRole {
RoleId = adminRole, View = PageDefinition.AllowedEnum.Yes, Edit = PageDefinition.AllowedEnum.Yes, Remove = PageDefinition.AllowedEnum.Yes,
});
while ((role = PageDefinition.AllowedRole.Find(page.AllowedRoles, editorRole)) != null)
{
page.AllowedRoles.Remove(role);
}
page.AllowedRoles.Add(new PageDefinition.AllowedRole {
RoleId = editorRole, View = PageDefinition.AllowedEnum.Yes, Edit = PageDefinition.AllowedEnum.Yes,
});
await page.SaveAsync();
}
}
}
return(Reload(null, Reload: ReloadEnum.ModuleParts));
}
private GridDefinition GetGridModel()
{
return(new GridDefinition {
ModuleGuid = Module.ModuleGuid,
SettingsModuleGuid = Module.PermanentGuid,
RecordType = typeof(BrowseItem),
AjaxUrl = GetActionUrl(nameof(HttpModulesBrowse_GridData)),
SortFilterStaticData = (List <object> data, int skip, int take, List <DataProviderSortInfo> sorts, List <DataProviderFilterInfo> filters) => {
DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(data, skip, take, sorts, filters);
return new DataSourceResult {
Data = recs.Data.ToList <object>(),
Total = recs.Total,
};
},
DirectDataAsync = (int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => {
HttpApplication httpApps = HttpContext.ApplicationInstance;
HttpModuleCollection httpModuleCollections = httpApps.Modules;
List <BrowseItem> items = (from k in httpModuleCollections.AllKeys select new BrowseItem(k)).ToList();
DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(items, skip, take, sort, filters);
DataSourceResult data = new DataSourceResult {
Data = recs.Data.ToList <object>(),
Total = recs.Total
};
return Task.FromResult(data);
},
});
}
private GridDefinition GetGridModel()
{
return(new GridDefinition {
InitialPageSize = 20,
ModuleGuid = Module.ModuleGuid,
SettingsModuleGuid = Module.PermanentGuid,
RecordType = typeof(BrowseItem),
AjaxUrl = GetActionUrl(nameof(AddonsBrowse_GridData)),
SortFilterStaticData = (List <object> data, int skip, int take, List <DataProviderSortInfo> sorts, List <DataProviderFilterInfo> filters) => {
DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(data, skip, take, sorts, filters);
foreach (BrowseItem r in recs.Data)
{
r.Module = Module;
}
return new DataSourceResult {
Data = recs.Data.ToList <object>(),
Total = recs.Total,
};
},
DirectDataAsync = (int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => {
List <VersionManager.AddOnProduct> list = VersionManager.GetAvailableAddOns();
DataSourceResult data = new DataSourceResult {
Data = (from l in list select new BrowseItem(Module, l)).ToList <object>(),
Total = list.Count,
};
return Task.FromResult(data);
},
});
}
public async Task <DataProviderGetRecords <RoleDefinition> > GetItemsAsync()
{
DataProviderGetRecords <RoleDefinition> list = await DataProvider.GetRecordsAsync(0, 0, null, null);
list.Data.Insert(0, MakeSuperuserRole());
return(list);
}
internal static GridDefinition GetGridModel(bool header)
{
return(new GridDefinition()
{
SizeStyle = GridDefinition.SizeStyleEnum.SizeToFit,
ResourceRedirect = Manager.CurrentModuleEdited,
RecordType = typeof(ModuleDefinition.GridAllowedUser),
PageSizes = new List <int>()
{
5, 10, 20
},
ShowHeader = header,
AjaxUrl = Utility.UrlFor(typeof(AllowedUsersController), nameof(AllowedUsersController.AllowedUsersEdit_SortFilter)),
SortFilterStaticData = (List <object> data, int skip, int take, List <DataProviderSortInfo> sorts, List <DataProviderFilterInfo> filters) => {
DataProviderGetRecords <ModuleDefinition.GridAllowedUser> recs = DataProviderImpl <ModuleDefinition.GridAllowedUser> .GetRecords(data, skip, take, sorts, filters);
return new DataSourceResult {
Data = recs.Data.ToList <object>(),
Total = recs.Total,
};
},
DeletedMessage = __ResStr("removeMsg", "User {0} has been removed"),
DeleteConfirmationMessage = __ResStr("confimMsg", "Are you sure you want to remove user {0}?"),
DeletedColumnDisplay = nameof(ModuleDefinition.GridAllowedUser.DisplayUserName),
});
}
private GridDefinition GetGridModel()
{
return(new GridDefinition {
ModuleGuid = Module.ModuleGuid,
SettingsModuleGuid = Module.PermanentGuid,
PageSizes = new List <int>()
{
5, 10, 20, 50
},
RecordType = typeof(BrowseItem),
AjaxUrl = GetActionUrl(nameof(BrowseLog_GridData)),
DirectDataAsync = async(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => {
FlushLog();
DataProviderSortInfo.UpdateAlternateSortColumn(sort, filters, "UserId", "UserName");
using (LogRecordDataProvider dataProvider = LogRecordDataProvider.GetLogRecordDataProvider()) {
DataProviderGetRecords <LogRecord> browseItems = await dataProvider.GetItemsAsync(skip, take, sort, filters);
return new DataSourceResult {
Data = (from s in browseItems.Data select new BrowseItem(Module, s)).ToList <object>(),
Total = browseItems.Total
};
}
},
});
}
private GridDefinition GetGridModel()
{
return(new GridDefinition {
InitialPageSize = 10,
ModuleGuid = Module.ModuleGuid,
SettingsModuleGuid = Module.PermanentGuid,
RecordType = typeof(BrowseItem),
AjaxUrl = GetActionUrl(nameof(TemplateGrid_SortFilter)),
SortFilterStaticData = (List <object> data, int skip, int take, List <DataProviderSortInfo> sorts, List <DataProviderFilterInfo> filters) => {
DataProviderGetRecords <BrowseItem> recs = DataProviderImpl <BrowseItem> .GetRecords(data, skip, take, sorts, filters);
return new DataSourceResult {
Data = recs.Data.ToList <object>(),
Total = recs.Total,
};
},
DirectDataAsync = (int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => {
DataProviderGetRecords <EntryElement> browseItems = DataProviderImpl <EntryElement> .GetRecords(GetRandomData(), skip, take, sort, filters);
return Task.FromResult(new DataSourceResult {
Data = (from s in browseItems.Data select new BrowseItem(s)).ToList <object>(),
Total = browseItems.Total
});
},
});
}
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
};
}
}
},
});
}
public DataProviderGetRecords <ResourceAttribute> GetItems()
{
DataProviderGetRecords <ResourceAttribute> recs = new DataProviderGetRecords <ResourceAttribute>();
recs.Data = (from d in AuthorizationResources.Values select d).ToList();//copy
recs.Total = recs.Data.Count();
return(recs);
}
public const int MAXUSERS = 50; // maximum # of users for a dropdown
public static async Task <bool> IsLargeUserBaseAsync()
{
using (UserDefinitionDataProvider userDP = new UserDefinitionDataProvider()) {
DataProviderGetRecords <UserDefinition> recs = await userDP.GetItemsAsync(0, 1, null, null);
return(recs.Total > MAXUSERS);
}
}
public async Task <DataProviderGetRecords <PageDefinition> > GetItemsAsync(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters)
{
DataProviderGetRecords <PageDefinition> list = await DataProvider.GetRecordsAsync(skip, take, sort, filters);
foreach (PageDefinition page in list.Data)
{
page.Temporary = false;
}
return(list);
}
private async Task LoadSitesCacheAsync()
{
DataProviderGetRecords <SiteDefinition> sites = await GetItemsAsync(0, 0, null, null);
foreach (SiteDefinition site in sites.Data)
{
site.OriginalSiteDomain = site.SiteDomain;
SiteCache.Add(site.SiteDomain.ToLower(), site);
}
}
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 <DataProviderGetRecords <BlogEntry> > GetItemsAsync(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters)
{
DataProviderGetRecords <BlogEntry> recs = await DataProvider.GetRecordsAsync(skip, take, sort, filters);
// TODO: This could be optimized for SQL using joins %%%%%%%%%%%%%%%%%%%
foreach (BlogEntry blogEntry in recs.Data)
{
await ObjectSupport.HandlePropertyAsync <MultiString>("Category", "GetCategoryAsync", blogEntry);
}
return(recs);
}
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);
}
public async Task Update()
{
using (UserDefinitionDataProvider userDP = new DataProvider.UserDefinitionDataProvider()) {
// get 5 sample users
DataProviderGetRecords <UserDefinition> recs = await userDP.GetItemsAsync(0, 5, null, null);
SerializableList <User> users = new SerializableList <User>((from u in recs.Data select new User {
UserId = u.UserId
}).ToList());
Prop1RO = users;
}
}
public async Task <DataProviderGetRecords <UserInfo> > GetItemsAsync(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters)
{
DataProviderGetRecords <UserInfo> list = await DataProvider.GetRecordsAsync(skip, take, sort, filters);
foreach (UserInfo l in list.Data)
{
if (string.IsNullOrWhiteSpace(l.Country))
{
l.Country = Globals.DefaultCountry;
}
}
return(list);
}
public async Task <string> RenderAsync(int model)
{
using (BlogCategoryDataProvider categoryDP = new BlogCategoryDataProvider()) {
DataProviderGetRecords <BlogCategory> data = await categoryDP.GetItemsAsync(0, 0, null, null);
List <SelectionItem <int> > list = (from c in data.Data orderby c.Category.ToString() select new SelectionItem <int> {
Text = c.Category.ToString(),
Tooltip = c.Description,
Value = c.Identity
}).ToList();
if (list.Count == 0)
{
list.Insert(0, new SelectionItem <int> {
Text = this.__ResStr("none", "(None Available)"),
Tooltip = this.__ResStr("noneTT", "There are no blog categories"),
Value = 0,
});
}
else
{
bool showSelect = false;
bool showAll = PropData.GetAdditionalAttributeValue("ShowAll", false);
if (model == 0 && !showAll)
{
showSelect = PropData.GetAdditionalAttributeValue("ShowSelectIfNone", false);
}
if (!showAll && !showSelect)
{
showSelect = PropData.GetAdditionalAttributeValue("ShowSelect", false);
}
if (showAll)
{
list.Insert(0, new SelectionItem <int> {
Text = this.__ResStr("all", "(All)"),
Tooltip = this.__ResStr("allTT", "Displays blogs from all available blog categories"),
Value = 0,
});
}
else if (showSelect)
{
list.Insert(0, new SelectionItem <int> {
Text = this.__ResStr("select", "(select)"),
Tooltip = this.__ResStr("selectTT", "Please select one of the available blog categories"),
Value = 0,
});
}
}
return(await DropDownListIntComponent.RenderDropDownListAsync(this, model, list, "yt_yetawf_blog_category"));
}
}
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);
}
