public Task <string> RenderViewAsync(PageEarModule module, PageEarModuleController.Model model)
{
HtmlBuilder hb = new HtmlBuilder();
if (Manager.EditMode)
{
hb.Append($@"
<div class='{Globals.CssDivWarning}'>
{HE(this.__ResStr("changeMod", "Change \"Module Settings\" to configure the page ear displayed"))}
</div>");
}
if (module.AdImage_Data.Length > 0 && module.CoverImage_Data.Length > 0 && !string.IsNullOrWhiteSpace(module.ClickUrl))
{
Manager.ScriptManager.AddLast($@"
$('body').peelback({{
adImage: '{JE(ImageHTML.FormatUrl(YetaWF.Core.Modules.ModuleImageSupport.ImageType, null, module.AdImage))}',
peelImage: '{JE(ImageHTML.FormatUrl(YetaWF.Core.Modules.ModuleImageSupport.ImageType, null, module.CoverImage))}',
clickURL: '{JE(module.ClickUrl)}',
smallSize: {module.SmallSize},
bigSize: {module.LargeSize},
autoAnimate: {(module.Animate ? "true" : "false")},
//gaTrack: true, //RFFU
//gaLabel: '#1 Stegosaurus',
debug: false
}});
// Listen for events that the page is changing
$YetaWF.registerPageChange(true, function () {{
// when the page is removed, we need to clean up
$('#peelback').remove();
}});");
}
return(Task.FromResult(hb.ToString()));
}
private string GetImage(PageDefinition pageDef)
{
string image;
string type;
if (pageDef.FavIcon != null)
{
type = PageDefinition.ImageType;
image = pageDef.FavIcon;
}
else if (Module.DefaultImage != null)
{
type = ModuleImageSupport.ImageType;
image = Module.DefaultImage;
}
else
{
type = PageDefinition.ImageType;
image = Guid.Empty.ToString();
}
int size;
switch (Module.Style)
{
default:
case PageBarModule.PanelStyleEnum.Vertical:
size = 32;
break;
case PageBarModule.PanelStyleEnum.Horizontal:
size = 32;
break;
}
return(ImageHTML.FormatUrl(type, null, image, size, size, Stretch: true));
}
/// <summary>
/// Renders an image <img> tag with specified attributes and returns HTML.
/// </summary>
/// <param name="imageType">The image type which must match a registered image handler. The YetaWF.Core.Image.ImageSupport.AddHandler method is used to register an image handler.</param>
/// <param name="width">The width of the image. Both <paramref name="width"/> and <paramref name="height"/> may be 0, in which case no size attributes are rendered.</param>
/// <param name="height">The height of the image. Both <paramref name="width"/> and <paramref name="height"/> may be 0, in which case no size attributes are rendered.</param>
/// <param name="model">The model representing the image.</param>
/// <param name="CacheBuster">A value that becomes part of the image URL, which can be used to defeat client-side caching. May be null.</param>
/// <param name="Alt">The text that is rendered as part of the <img> tag's Alt attribute. May be null in which case the text "Image" is used.</param>
/// <param name="ExternalUrl">Defines whether a full URL including domain is rendered (true) or whether just the path is used (false).</param>
/// <param name="SecurityType">The security type of the rendered image URL.</param>
/// <returns></returns>
public static string RenderImage(string imageType, int width, int height, string model,
string CacheBuster = null, string Alt = null, bool ExternalUrl = false, PageDefinition.PageSecurityType SecurityType = PageDefinition.PageSecurityType.Any)
{
string url = ImageHTML.FormatUrl(imageType, null, model, width, height, CacheBuster: CacheBuster, ExternalUrl: ExternalUrl, SecurityType: SecurityType);
YTagBuilder img = new YTagBuilder("img");
img.AddCssClass("t_preview");
img.Attributes.Add("src", url);
img.Attributes.Add("alt", Alt ?? __ResStr("altImg", "Image"));
return(img.ToString(YTagRenderMode.StartTag));
}
public async Task <ActionResult> RssFeed(Guid moduleGuid)
{
TextModule mod = (TextModule)await ModuleDefinition.LoadAsync(moduleGuid, AllowNone : true);
if (mod == null || !mod.Feed)
{
throw new Error(this.__ResStr("noFeed", "The feed is no longer available"));
}
ModuleAction action = await mod.GetAction_RssFeedAwait(mod.ModuleGuid);
string url = action.GetCompleteUrl();
SyndicationFeed feed;
List <SyndicationItem> items = new List <SyndicationItem>();
feed = new SyndicationFeed(mod.FeedTitle, mod.FeedSummary,
string.IsNullOrWhiteSpace(mod.FeedMainUrl) ? new Uri(url) : new Uri(Manager.CurrentSite.MakeUrl(mod.FeedMainUrl)),
items);
action = await mod.GetAction_RssDetailAsync(mod.FeedDetailUrl, mod.ModuleGuid, mod.AnchorId);
url = action.GetCompleteUrl();
SyndicationItem sItem = new SyndicationItem(mod.Title, mod.Contents, new Uri(url));
sItem.PublishDate = mod.FeedPublishDate ?? DateTime.MinValue;
items.Add(sItem);
if (mod.FeedImage != null)
{
feed.ImageUrl = new Uri(Manager.CurrentSite.MakeUrl(ImageHTML.FormatUrl(YetaWF.Core.Modules.ModuleImageSupport.ImageType, null, mod.FeedImage, CacheBuster: mod.DateUpdated.Ticks.ToString())));
}
feed.LastUpdatedTime = mod.FeedUpdateDate ?? DateTime.MinValue;
return(new RssResult(feed));
}
/// <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 Task <string> RenderAsync(string model)
{
HtmlBuilder hb = new HtmlBuilder();
hb.Append("<div class='yt_image t_display'>");
string imageType = PropData.GetAdditionalAttributeValue <string>("ImageType", null);
int width = PropData.GetAdditionalAttributeValue("Width", 0);
int height = PropData.GetAdditionalAttributeValue("Height", 0);
if (string.IsNullOrWhiteSpace(imageType) && model != null && (model.IsAbsoluteUrl() || model.StartsWith("/") || model.StartsWith("data:")))
{
if (width != 0 || height != 0)
{
throw new InternalError("Can't use Width or Height with external Urls");
}
YTagBuilder img = new YTagBuilder("img");
img.Attributes.Add("src", model);
if (!img.Attributes.ContainsKey("alt"))
{
img.Attributes.Add("alt", __ResStr("altImage", "Image"));
}
hb.Append(img.ToString(YTagRenderMode.Normal));
}
else
{
if (string.IsNullOrWhiteSpace(imageType))
{
throw new InternalError("No ImageType specified");
}
bool showMissing = PropData.GetAdditionalAttributeValue("ShowMissing", true);
if (string.IsNullOrWhiteSpace(model) && !showMissing)
{
return(Task.FromResult <string>(null));
}
string alt = null;
if (HtmlAttributes.ContainsKey("alt"))
{
alt = (string)HtmlAttributes["alt"];
}
string imgTag = ImageComponentBase.RenderImage(imageType, width, height, model, Alt: alt);
bool linkToImage = PropData.GetAdditionalAttributeValue("LinkToImage", false);
if (linkToImage)
{
YTagBuilder link = new YTagBuilder("a");
string imgUrl = ImageHTML.FormatUrl(imageType, null, model);
link.MergeAttribute("href", imgUrl);
link.MergeAttribute("target", "_blank");
link.MergeAttribute("rel", "noopener noreferrer");
link.InnerHtml = imgTag;
hb.Append(link.ToString(YTagRenderMode.Normal));
}
else
{
hb.Append(imgTag);
}
}
hb.Append("</div>");
return(Task.FromResult(hb.ToString()));
}
// 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 string MakeFlashUrl(string filename, int width = 0, int height = 0)
{
// always defeat browser caching for image selection
return(ImageHTML.FormatUrl(ImageSupport.ImageType, string.Format("{0},{1},{2}", FolderGuid.ToString(), SubFolder, FileType), filename, width, height, CacheBuster: DateTime.UtcNow.Ticks.ToString()));
}
