public async Task <ActionResult> CategoryHeader(int?blogEntry)
{
int category;
Manager.TryGetUrlArg <int>("BlogCategory", out category);
int entry = (int)(blogEntry ?? 0);
if (entry != 0)
{
using (BlogEntryDataProvider entryDP = new BlogEntryDataProvider()) {
BlogEntry data = await entryDP.GetItemAsync(entry);
if (data != null)
{
category = data.CategoryIdentity;
}
}
}
if (category != 0)
{
using (BlogCategoryDataProvider dataProvider = new BlogCategoryDataProvider()) {
BlogCategory data = await dataProvider.GetItemAsync(category);
if (data != null)
{
DisplayModel model = new DisplayModel();
model.SetData(data);
Module.Title = data.Category.ToString();
return(View(model));
}
}
}
return(new EmptyResult());
}
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 async Task <ActionResult> Remove(int blogCategory)
{
using (BlogCategoryDataProvider dataProvider = new BlogCategoryDataProvider()) {
await dataProvider.RemoveItemAsync(blogCategory);
return(Reload(null, Reload: ReloadEnum.ModuleParts));
}
}
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 <ActionResult> CategoryDisplay(int blogCategory)
{
using (BlogCategoryDataProvider dataProvider = new BlogCategoryDataProvider()) {
BlogCategory data = await dataProvider.GetItemAsync(blogCategory);
if (data == null)
{
throw new Error(this.__ResStr("notFound", "Blog category with id {0} not found."), blogCategory);
}
DisplayModel model = new DisplayModel();
model.SetData(data);
Module.Title = this.__ResStr("modTitle", "Blog Category \"{0}\"", data.Category.ToString());
return(View(model));
}
}
public async Task <ActionResult> CategoryAdd_Partial(AddModel model)
{
if (!ModelState.IsValid)
{
return(PartialView(model));
}
using (BlogCategoryDataProvider dataProvider = new BlogCategoryDataProvider()) {
if (!await dataProvider.AddItemAsync(model.GetData()))
{
ModelState.AddModelError(nameof(model.Category), this.__ResStr("alreadyExists", "A blog category named \"{0}\" already exists.", model.Category));
return(PartialView(model));
}
return(FormProcessed(model, this.__ResStr("okSaved", "New blog category saved"), OnPopupClose: OnPopupCloseEnum.ReloadModule));
}
}
internal async Task UpdateDataAsync()
{
BlogConfigData config = await BlogConfigDataProvider.GetConfigAsync();
GravatarsEnabled = config.ShowGravatar;
using (BlogCategoryDataProvider categoryDP = new BlogCategoryDataProvider()) {
BlogCategory cat = await categoryDP.GetItemAsync(CategoryIdentity);
if (cat == null)
{
throw new InternalError("Category with id {0} not found", CategoryIdentity);
}
ShowCaptcha = cat.UseCaptcha;
ShowGravatar = GravatarsEnabled;
}
OpenForComments = await TestOpenForCommentsAsync(EntryIdentity);
}
private GridDefinition GetGridModel()
{
return(new GridDefinition {
ModuleGuid = Module.ModuleGuid,
SettingsModuleGuid = Module.PermanentGuid,
RecordType = typeof(BrowseItem),
AjaxUrl = GetActionUrl(nameof(CategoriesBrowse_GridData)),
DirectDataAsync = async(int skip, int take, List <DataProviderSortInfo> sort, List <DataProviderFilterInfo> filters) => {
using (BlogCategoryDataProvider dataProvider = new BlogCategoryDataProvider()) {
DataProviderGetRecords <BlogCategory> 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
};
}
},
});
}
public async Task <ModuleAction> GetAction_RssFeedAsync(int blogCategory = 0)
{
BlogConfigData config = await BlogConfigDataProvider.GetConfigAsync();
if (!config.Feed)
{
return(null);
}
//if (blogCategory == 0)
// manager.TryGetUrlArg<int>("BlogCategory", out blogCategory);
object qargs = null, qargsHR = null;
if (blogCategory != 0)
{
qargs = new { BlogCategory = blogCategory, };
using (BlogCategoryDataProvider dataProvider = new BlogCategoryDataProvider()) {
BlogCategory data = await dataProvider.GetItemAsync(blogCategory);
if (data != null)
{
qargsHR = new { Title = data.Category.ToString().Truncate(80) }
}
;
}
}
return(new ModuleAction(this)
{
Url = Utility.UrlFor(typeof(RssController), nameof(RssController.RssFeed)),
QueryArgs = qargs,
QueryArgsHR = qargsHR,
Image = await CustomIconAsync("RssFeed.png"),
Style = ModuleAction.ActionStyleEnum.NewWindow,
LinkText = this.__ResStr("rssLink", "RSS Feed"),
MenuText = this.__ResStr("rssMenu", "RSS Feed"),
Tooltip = this.__ResStr("rssTT", "Display the blog's RSS Feed"),
Legend = this.__ResStr("rssLegend", "Displays the blog's RSS Feed"),
Category = ModuleAction.ActionCategoryEnum.Read,
Mode = ModuleAction.ActionModeEnum.Any,
Location = ModuleAction.ActionLocationEnum.ModuleLinks,
});
}
}
public async Task <ActionResult> CategoryEdit_Partial(EditModel model)
{
int originalCategory = model.Identity;
using (BlogCategoryDataProvider dataProvider = new BlogCategoryDataProvider()) {
// get the original item
BlogCategory data = await dataProvider.GetItemAsync(originalCategory);
if (data == null)
{
throw new Error(this.__ResStr("alreadyDeletedId", "The blog category with id {0} has been removed and can no longer be updated.", originalCategory));
}
if (!ModelState.IsValid)
{
return(PartialView(model));
}
// save updated item
data = model.GetData(data); // merge new data into original
model.SetData(data); // and all the data back into model for final display
switch (await dataProvider.UpdateItemAsync(data))
{
default:
case UpdateStatusEnum.RecordDeleted:
throw new Error(this.__ResStr("alreadyDeleted", "The blog category named \"{0}\" has been removed and can no longer be updated.", model.Category.ToString()));
case UpdateStatusEnum.NewKeyExists:
ModelState.AddModelError(nameof(model.Category), this.__ResStr("alreadyExists", "A blog category named \"{0}\" already exists.", model.Category.ToString()));
return(PartialView(model));
case UpdateStatusEnum.OK:
break;
}
return(FormProcessed(model, this.__ResStr("okSaved", "Blog category saved"), OnPopupClose: OnPopupCloseEnum.ReloadModule));
}
}
// Windows RSS Publisher's Guide http://blogs.msdn.com/b/rssteam/archive/2005/08/02/publishersguide.aspx
public async Task <ActionResult> RssFeed(int?blogCategory)
{
BlogConfigData config = await BlogConfigDataProvider.GetConfigAsync();
if (!config.Feed)
{
throw new Error(this.__ResStr("noFeed", "The feed is no longer available"));
}
int categoryIdentity = blogCategory ?? 0;
BlogCategory category = null;
if (categoryIdentity != 0)
{
using (BlogCategoryDataProvider categoryDP = new BlogCategoryDataProvider()) {
category = await categoryDP.GetItemAsync(categoryIdentity);
if (!category.Syndicated)
{
throw new Error(this.__ResStr("noFeed", "The feed is no longer available"));
}
}
}
using (BlogEntryDataProvider dataProvider = new BlogEntryDataProvider()) {
List <DataProviderSortInfo> sort = new List <DataProviderSortInfo> {
new DataProviderSortInfo {
Field = nameof(BlogEntry.DatePublished), Order = DataProviderSortInfo.SortDirection.Descending
},
};
List <DataProviderFilterInfo> filters = new List <DataProviderFilterInfo> {
new DataProviderFilterInfo {
Field = nameof(BlogEntry.Published), Operator = "==", Value = true
},
};
if (categoryIdentity != 0)
{
filters = DataProviderFilterInfo.Join(filters, new DataProviderFilterInfo {
Field = nameof(BlogEntry.CategoryIdentity), Operator = "==", Value = categoryIdentity
});
}
DataProviderGetRecords <BlogEntry> data = await dataProvider.GetItemsAsync(0, 0, sort, filters);
string url = string.IsNullOrWhiteSpace(config.FeedMainUrl) ? Manager.CurrentSite.HomePageUrl : config.FeedMainUrl;
List <SyndicationItem> items = new List <SyndicationItem>();
EntryDisplayModule dispMod = new EntryDisplayModule();
DateTime lastUpdated = DateTime.MinValue;
foreach (BlogEntry blogEntry in data.Data)
{
if (categoryIdentity == 0)
{
using (BlogCategoryDataProvider categoryDP = new BlogCategoryDataProvider()) {
category = await categoryDP.GetItemAsync(blogEntry.CategoryIdentity);
if (!category.Syndicated)
{
continue;
}
}
}
ModuleAction viewAction = await dispMod.GetAction_DisplayAsync(blogEntry.Identity);
if (viewAction == null)
{
continue;
}
SyndicationItem sItem = new SyndicationItem(blogEntry.Title.ToString(), blogEntry.Text, new Uri(viewAction.GetCompleteUrl()));
DateTime updDate = blogEntry.DateUpdated ?? blogEntry.DateCreated;
sItem.LastUpdatedTime = updDate;
if (!string.IsNullOrEmpty(category.SyndicationEmail))
{
sItem.Authors.Add(new SyndicationPerson(category.SyndicationEmail));
}
sItem.Categories.Add(new SyndicationCategory(category.Category.ToString()));
if (!string.IsNullOrEmpty(category.SyndicationCopyright.ToString()))
{
sItem.Copyright = new TextSyndicationContent(category.SyndicationCopyright.ToString());
}
sItem.PublishDate = blogEntry.DatePublished;
if (!string.IsNullOrEmpty(blogEntry.DisplayableSummary))
{
sItem.Summary = new TextSyndicationContent(blogEntry.DisplayableSummary);
}
lastUpdated = updDate > lastUpdated ? updDate : lastUpdated;
items.Add(sItem);
}
SyndicationFeed feed;
if (categoryIdentity != 0)
{
feed = new SyndicationFeed(category.Category.ToString(), category.Description.ToString(), new Uri(Manager.CurrentSite.MakeUrl(url)), items);
}
else
{
feed = new SyndicationFeed(config.FeedTitle, config.FeedSummary, new Uri(Manager.CurrentSite.MakeUrl(url)), items);
}
if (config.FeedImage != null)
{
feed.ImageUrl = new Uri(Manager.CurrentSite.MakeUrl(ImageHTML.FormatUrl(BlogConfigData.ImageType, null, config.FeedImage))); //$$$ caching issue
}
if (lastUpdated != DateTime.MinValue)
{
feed.LastUpdatedTime = lastUpdated;
}
return(new RssResult(feed));
}
}
public BrowseItem(EntriesBrowseModule module, BlogCategoryDataProvider categoryDP, BlogEntry data)
{
Module = module;
ObjectSupport.CopyData(data, this);
}
