public IElementSettings Read(long tenantId, long elementId, IUnitOfWork unitOfWork = null)
{
IDatabaseManager dbm = _databaseManagerFactory.GetDatabaseManager(unitOfWork);
try
{
IElementSettings elementSettings = null;
dbm.SetStoredProcedure("cms.ReadElement");
dbm.AddParameter("@TenantId", FieldType.BigInt, tenantId);
dbm.AddParameter("@ElementId", FieldType.BigInt, elementId);
dbm.ExecuteReader();
if (dbm.Read())
{
elementSettings = GetElementSettingsFromDatabaseManager(dbm);
}
return(elementSettings);
}
finally
{
if (unitOfWork == null)
{
dbm.Dispose();
}
}
}
public IActionResult ReadUpload(long elementId, long uploadId, string format)
{
// Get element service
long tenantId = _authenticationService.TenantId;
IElementSettings elementSettings = _elementService.Read(tenantId, elementId, false);
IBasicElementService elementService = _elementFactory.GetElementService(elementSettings.ElementTypeId);
// If images not supported, go no further
if (!(elementService is IUploadElementService))
{
return(null);
}
// Get specified image
if (format == null)
{
format = "preview";
}
Upload upload = ((IUploadElementService)elementService).ReadUpload(tenantId, elementId, uploadId, format);
if (upload == null)
{
return(null);
}
// Return file content result
return(new FileContentResult(upload.Content, upload.ContentType)
{
FileDownloadName = upload.Name
});
}
public void Update(IElementSettings settings, IUnitOfWork unitOfWork = null)
{
// Get HTML uploads that are being referenced by updated HTML
HtmlSettings htmlSettings = (HtmlSettings)settings;
htmlSettings.Html = SanitizeHtml(htmlSettings.Html);
htmlSettings.Uploads = GetHtmlUploads(htmlSettings);
// Get previous HTML settings
HtmlSettings previousHtmlSettings = (HtmlSettings)New(settings.TenantId);
previousHtmlSettings.ElementId = settings.ElementId;
_htmlRepository.Read(previousHtmlSettings, unitOfWork);
// Get HTML uploads that are no longer used
List <HtmlUpload> uploadsToDelete = new List <HtmlUpload>();
Dictionary <long, HtmlUpload> uploadsById = htmlSettings.Uploads.GroupBy(u => u.HtmlUploadId).ToDictionary(u => u.Key, u => u.First());
foreach (HtmlUpload previousHtmlUpload in previousHtmlSettings.Uploads)
{
if (!uploadsById.ContainsKey(previousHtmlUpload.HtmlUploadId))
{
uploadsToDelete.Add(previousHtmlUpload);
}
}
// Update HTML element
_htmlRepository.Update(htmlSettings, unitOfWork);
// Delete HTML uploads that are no longer used
DeleteUploads(uploadsToDelete, unitOfWork);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
IElementContent elementContent = _testimonialService.GetContent(settings, pageContext, unitOfWork);
elementContent.PartialViewName = "TestimonialCarousel"; // Display testimonial carousel front end, rather that the standard testimonial UI
return(elementContent);
}
/// <summary>
/// Get table content from table settings.
/// </summary>
/// <param name="settings">Table settings.</param>
/// <param name="pageContext">Page context.</param>
/// <param name="unitOfWork">Unit of work.</param>
/// <returns>Element content.</returns>
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
TableSettings tableSettings = (TableSettings)settings;
TableContent content = new TableContent {
PartialViewName = "Table", Rows = new List <List <string> >()
};
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(tableSettings.Rows)))
{
using (StreamReader sr = new StreamReader(ms))
{
string line;
while ((line = sr.ReadLine()) != null)
{
List <string> values = _stringService.GetCsvValues(line);
if (tableSettings.ShowHeaders && content.Headers == null)
{
content.Headers = values;
}
else
{
content.Rows.Add(values);
}
}
}
}
return(content);
}
public void Update(IElementSettings settings, IUnitOfWork unitOfWork = null)
{
// Get page list typed settings
PageListSettings pageListSettings = (PageListSettings)settings;
// Set non mandatory text fields null if they only contain white space
if (string.IsNullOrWhiteSpace(pageListSettings.DisplayName))
{
pageListSettings.DisplayName = null;
}
if (string.IsNullOrWhiteSpace(pageListSettings.MoreMessage))
{
pageListSettings.MoreMessage = null;
}
if (string.IsNullOrWhiteSpace(pageListSettings.Preamble))
{
pageListSettings.Preamble = null;
}
if (string.IsNullOrWhiteSpace(pageListSettings.NoPagesMessage))
{
pageListSettings.NoPagesMessage = null;
}
// Do the update
_pageListRepository.Update(pageListSettings, unitOfWork);
}
public IElementSettings New(long tenantId)
{
IElementSettings elementSettings = _testimonialService.New(tenantId);
elementSettings.ElementTypeId = ElementTypeId; // Do not want to use testimonial element type identifier
return(elementSettings);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
ContactContent content = new ContactContent {
PartialViewName = "Contact"
};
ContactSettings contactSettings = (ContactSettings)settings;
if (contactSettings.FacebookUsername != null)
{
content.FacebookUrl = string.Format("https://www.facebook.com/{0}", contactSettings.FacebookUsername);
}
if (contactSettings.InstagramUsername != null)
{
content.InstagramUrl = string.Format("https://www.instagram.com/{0}", contactSettings.InstagramUsername);
}
if (contactSettings.LinkedInCompanyUsername != null)
{
content.LinkedInCompanyUrl = string.Format("https://www.linkedin.com/company/{0}", contactSettings.LinkedInCompanyUsername);
}
if (contactSettings.LinkedInPersonalUsername != null)
{
content.LinkedInPersonalUrl = string.Format("https://www.linkedin.com/in/{0}", contactSettings.LinkedInPersonalUsername);
}
if (contactSettings.TwitterUsername != null)
{
content.TwitterUrl = string.Format("https://twitter.com/{0}", contactSettings.TwitterUsername);
}
if (contactSettings.YouTubeChannelId != null)
{
content.YouTubeChannelUrl = string.Format("https://www.youtube.com/channel/{0}", contactSettings.YouTubeChannelId);
}
return(content);
}
/// <summary>
/// Reads primary element details.
/// </summary>
/// <param name="tenantId">Tenant that element associated with.</param>
/// <param name="elementId">Element identifier.</param>
/// <param name="loadCustomSettings">Set false to retrieve only those settings common to all elements. Set true to retrieve settings common to all elements and element specific settings.</param>
/// <param name="unitOfWork">Unit of work.</param>
/// <returns>Element setings (null if element not found).</returns>
public IElementSettings Read(long tenantId, long elementId, bool loadCustomSettings, IUnitOfWork unitOfWork = null)
{
// Get core element details
IElementSettings elementSettings = _elementRepository.Read(tenantId, elementId, unitOfWork);
if (elementSettings == null)
{
return(null);
}
// Now we know the type of element requested, we can get custom element settings
IBasicElementService customElementService = _elementFactory.GetElementService(elementSettings.ElementTypeId);
IElementSettings customElementSettings = customElementService.New(elementSettings.TenantId);
customElementSettings.ElementId = elementSettings.ElementId;
customElementSettings.Name = elementSettings.Name;
// If "advanced" element, populate custom settings
if (loadCustomSettings && customElementService is IAdvancedElementService)
{
((IAdvancedElementService)customElementService).Read(customElementSettings, unitOfWork);
}
// Return fully populated element settings
return(customElementSettings);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Construct nav bar content
NavBarContent navBarContent = new NavBarContent {
PartialViewName = "NavBar", PageTabs = new List <NavBarPageTab>()
};
// Get full page information for pages identified in nav bar tabs
NavBarSettings navBarSettings = (NavBarSettings)settings;
foreach (NavBarTab tab in navBarSettings.Tabs)
{
Page page = _pageService.Read(tab.TenantId, tab.PageId, unitOfWork);
if (page != null)
{
Page pageHierarchy = pageContext.Hierarchy;
bool active = false;
while (!active && pageHierarchy != null)
{
active = pageHierarchy.PageId == page.PageId;
pageHierarchy = pageHierarchy.ChildPages.Count == 0 ? null : pageHierarchy.ChildPages[0];
}
navBarContent.PageTabs.Add(new NavBarPageTab {
Page = page, Name = tab.Name, Active = active
});
}
}
// Return nav bar content
return(navBarContent);
}
private async Task <ElementRender> GetElementRender(long tenantId, Guid elementTypeId, long elementId, long pageId)
{
IElementSettings elementSettings = await _elementServiceFactory.ReadElementSettingsAsync(tenantId, elementTypeId, elementId);
object elementContent = await _elementServiceFactory.ReadElementContentAsync(tenantId, elementTypeId, elementId, pageId);
if (elementSettings == null)
{
return new ElementRender {
PartialViewName = "~/Views/Elements/NotFound.cshtml"
}
}
;
ElementView elementView = new ElementView
{
Settings = elementSettings,
Content = elementContent
};
return(new ElementRender
{
PartialViewName = $"~/Views/Elements/{elementTypeId}.cshtml",
ElementView = elementView
});
}
/// <summary>
/// Retrieves dynamic element content.
/// </summary>
/// <param name="settings">Contains element settings.</param>
/// <param name="pageContext">Page context.</param>
/// <param name="unitOfWork">Unit of work.</param>
/// <returns>Element content.</returns>
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
IDictionary <object, object> items = _webHelperService.GetItems();
return(new TestimonialContent {
PartialViewName = "Testimonial", Items = items
});
}
/// <summary>
/// Retrieves dynamic element content.
/// </summary>
/// <param name="settings">Contains element settings.</param>
/// <param name="pageContext">Page context.</param>
/// <param name="unitOfWork">Unit of work.</param>
/// <returns>Element content.</returns>
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
long masterPageId = Convert.ToInt64(pageContext.RouteValues["masterpageid"]);
return(new MasterPageContent {
PartialViewName = "UpdateMasterPageZonesAdmin", FormContext = masterPageId.ToString()
});
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Get tag cloud content
TagCloudContent content = new TagCloudContent {
PartialViewName = "TagCloud"
};
// Get folder that tag cloud is targetting
TagCloudSettings tagCloudSettings = (TagCloudSettings)settings;
long tenantId = tagCloudSettings.PageTenantId ?? pageContext.Page.TenantId;
long pageId = tagCloudSettings.PageId ?? pageContext.Page.PageId;
if (pageId == pageContext.Page.PageId)
{
content.Page = pageContext.Page;
}
else
{
content.Page = _pageService.Read(tenantId, pageId, unitOfWork);
}
// Get tagged list
content.TaggedList = new List <TagTagged>();
foreach (Tag tag in pageContext.Tags)
{
IList <Tag> tags = pageContext.Tags.Where(t => t.Name != tag.Name).ToList();
content.TaggedList.Add(new TagTagged
{
Tag = tag,
RemoveTaggedList = _pagePortalService.GetTagsAsTextString(TagVariables.Separator, tags)
});
}
// Get tags list if no tags currently selected
if (content.TaggedList.Count == 0)
{
content.TagList = _pageService.ListTags(tenantId, pageId, tagCloudSettings.Recursive, unitOfWork);
}
else
{
content.TagList = new List <TagCount>();
}
// Get related tags list if tags currently selected
if (content.TaggedList.Count > 0)
{
content.RelatedTagList = _pageService.ListTaggedPageTags(tenantId, pageId, pageContext.Tags, tagCloudSettings.Recursive, unitOfWork);
content.Tags = _pagePortalService.GetTagsAsTextString(TagVariables.Separator, pageContext.Tags);
}
else
{
content.RelatedTagList = new List <TagCount>();
}
// Return result
return(content);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
long pageId = pageContext.Page.PageId;
long pageZoneId = Convert.ToInt64(pageContext.RouteValues["pagezoneid"]);
return(new PageZoneContent {
PartialViewName = "PageZoneAdmin", PageId = pageId, PageZoneId = pageZoneId
});
}
/// <summary>
/// Deletes an element.
/// </summary>
/// <param name="tenantId">The tenant that element to delete belongs to.</param>
/// <param name="elementId">Identifies the element to delete.</param>
/// <param name="unitOfWork">Unit of work.</param>
public void Delete(long tenantId, long elementId, IUnitOfWork unitOfWork = null)
{
IElementSettings elementSettings = Read(tenantId, elementId, false, unitOfWork);
if (elementSettings != null)
{
Delete(tenantId, elementSettings.ElementTypeId, elementId, unitOfWork);
}
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Get album content
ElementContent content = new ElementContent {
PartialViewName = "Album"
};
// Return result
return(content);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
CodeSnippetSettings codeSnippetSettings = (CodeSnippetSettings)settings;
CodeSnippetContent content = new CodeSnippetContent
{
PartialViewName = "CodeSnippet",
CssClass = GetCssClass(codeSnippetSettings.Language)
};
return(content);
}
/// <summary>
/// Creates any new elements that are required.
/// </summary>
/// <param name="masterPageZone">The updated master page zone.</param>
/// <param name="unitOfWork">Unit of work.</param>
private void CreateNewElements(MasterPageZone masterPageZone, IUnitOfWork unitOfWork)
{
foreach (MasterPageZoneElement masterPageZoneElement in masterPageZone.MasterPageZoneElements)
{
if (masterPageZoneElement.ElementId == 0)
{
IElementSettings element = _elementService.New(masterPageZone.TenantId, masterPageZoneElement.Element.ElementTypeId);
element.Name = masterPageZoneElement.Element.Name.Trim();
long elementId = _elementService.Create(element, unitOfWork);
masterPageZoneElement.ElementId = elementId;
masterPageZoneElement.Element.ElementId = elementId;
}
}
}
/// <summary>
/// Creates a new element.
/// </summary>
/// <param name="settings">New element settings.</param>
/// <param name="unitOfWork">Unit of work.</param>
/// <returns>Newly allocated element identifier.</returns>
public long Create(IElementSettings settings, IUnitOfWork unitOfWork = null)
{
try
{
IAdvancedElementService customElementService = (IAdvancedElementService)_elementFactory.GetElementService(settings.ElementTypeId);
ICustomElementValidator customElementValidator = _elementFactory.GetElementValidator(settings.ElementTypeId);
IUnitOfWork localUnitOfWork = unitOfWork == null?_unitOfWorkFactory.CreateUnitOfWork() : null;
try
{
if (customElementValidator != null)
{
customElementValidator.ValidateCreate(settings, unitOfWork ?? localUnitOfWork);
}
settings.ElementId = _elementRepository.Create(settings, unitOfWork ?? localUnitOfWork);
if (customElementService != null)
{
customElementService.Create(settings, unitOfWork ?? localUnitOfWork);
}
if (localUnitOfWork != null)
{
localUnitOfWork.Commit();
}
return(settings.ElementId);
}
catch
{
if (localUnitOfWork != null)
{
localUnitOfWork.Rollback();
}
throw;
}
finally
{
if (localUnitOfWork != null)
{
localUnitOfWork.Dispose();
}
}
}
catch (ValidationErrorException)
{
throw;
}
catch (Exception ex)
{
throw new ValidationErrorException(new ValidationError(null, ApplicationResource.UnexpectedErrorMessage), ex);
}
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Construct element content
FooterContent footerContent = new FooterContent();
footerContent.PartialViewName = "Footer";
// Populate element content according to element settings
FooterSettings footerSettings = (FooterSettings)settings;
footerContent.FormattedMessage = FormatMessage(footerSettings.Message);
// Return resulting element content
return(footerContent);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Construct element content
HtmlContent htmlContent = new HtmlContent();
htmlContent.PartialViewName = "Html";
// Populate element content according to element settings
HtmlSettings htmlSettings = (HtmlSettings)settings;
htmlContent.FormattedHtml = FormatHtml(htmlSettings.Html);
// Return resulting element content
return(htmlContent);
}
private IList <FormFieldSet> GetFieldSets(Dictionary <Guid, ElementType> elementTypesById, PageZone pageZone)
{
List <FormFieldSet> fieldSets = new List <FormFieldSet>();
foreach (PageZoneElement pageZoneElement in pageZone.PageZoneElements)
{
FormFieldSet fieldSet = new FormFieldSet {
Fields = new Dictionary <string, IFormField>()
};
IElementSettings element = _elementService.Read(pageZoneElement.TenantId, pageZoneElement.ElementTypeId, pageZoneElement.ElementId);
fieldSet.Fields.Add("name", GetNameTextField(pageZoneElement.PageZoneElementId, element.Name));
fieldSet.Fields.Add("elementType", GetElementTypeSelectListField(pageZoneElement.PageZoneElementId, pageZoneElement.ElementTypeId, elementTypesById, null));
fieldSets.Add(fieldSet);
}
return(fieldSets);
}
/// <summary>
/// Updates an element's details.
/// </summary>
/// <param name="settings">Updated element settings.</param>
/// <param name="unitOfWork">Unit of work.</param>
public void Update(IElementSettings settings, IUnitOfWork unitOfWork = null)
{
// Ensure sort orders are correct
TestimonialSettings testimonialSettings = (TestimonialSettings)settings;
for (int index = 0; index < testimonialSettings.Comments.Count; index++)
{
TestimonialComment testimonialComment = testimonialSettings.Comments[index];
testimonialComment.SortOrder = index;
testimonialComment.AuthorTitle = string.IsNullOrWhiteSpace(testimonialComment.AuthorTitle) ? string.Empty : testimonialComment.AuthorTitle.Trim();
testimonialComment.CommentDate = string.IsNullOrWhiteSpace(testimonialComment.CommentDate) ? string.Empty : testimonialComment.CommentDate.Trim();
}
// Do the update
_testimonialRepository.Update((TestimonialSettings)settings, unitOfWork);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
LatestThreadSettings latestThreadSettings = (LatestThreadSettings)settings;
long tenantId = latestThreadSettings.PageTenantId ?? pageContext.Page.TenantId;
long pageId = latestThreadSettings.PageId ?? pageContext.Page.PageId;
ForumThreads threads = null;
if (pageContext.Tags.Count == 0)
{
threads = _forumRepository.ListLatestThreads(tenantId, pageId, latestThreadSettings.PageSize, latestThreadSettings.Recursive, unitOfWork);
}
else
{
threads = _forumRepository.ListTaggedLatestThreads(tenantId, pageId, latestThreadSettings.PageSize, pageContext.Tags, latestThreadSettings.Recursive, unitOfWork);
}
return(new LatestThreadContent {
PartialViewName = "LatestThread", Threads = threads
});
}
public void Read(IElementSettings settings, IUnitOfWork unitOfWork = null)
{
IDatabaseManager dbm = _databaseManagerFactory.GetDatabaseManager(unitOfWork);
try
{
dbm.SetStoredProcedure("cms.ReadElement");
dbm.AddParameter("@TenantId", FieldType.BigInt, settings.TenantId);
dbm.AddParameter("@ElementId", FieldType.BigInt, settings.ElementId);
dbm.ExecuteReader();
dbm.Read();
settings.Name = (string)dbm.DataReaderValue("Name");
}
finally
{
if (unitOfWork == null)
{
dbm.Dispose();
}
}
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Construct element content
ShareContent shareContent = new ShareContent();
// Get this page's URL
// UrlParameters urlParameters = new UrlParameters { RouteName = "ReadPage", RouteValues = new { pageid = pageContext.Page.PageId, description = pageContext.Page.Description } };
string url = _webHelperService.GetRequestUrl(); // _webHelperService.GetUrl(urlParameters);
// Populate element content
shareContent.PartialViewName = "Share";
shareContent.Description = _webHelperService.UrlEncode(pageContext.Page.Description ?? string.Empty);
shareContent.Hashtags = _webHelperService.UrlEncode(string.Empty);
shareContent.Image = _webHelperService.UrlEncode(string.Empty);
shareContent.IsVideo = _webHelperService.UrlEncode(string.Empty);
shareContent.Title = _webHelperService.UrlEncode(pageContext.Page.Name);
shareContent.Url = _webHelperService.UrlEncode(url);
// Return resulting element content
return(shareContent);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Get carousel content
IDictionary <object, object> items = _webHelperService.GetItems();
CarouselContent content = new CarouselContent {
PartialViewName = "Carousel", Pages = new List <Page>(), Items = items
};
// Populate pages
foreach (CarouselSlide slide in ((CarouselSettings)settings).Slides)
{
Page page = null;
if (slide.PageId.HasValue)
{
page = _pageService.Read(slide.TenantId, slide.PageId.Value, unitOfWork);
}
content.Pages.Add(page);
}
// Return result
return(content);
}
public IElementContent GetContent(IElementSettings settings, IPageContext pageContext, IUnitOfWork unitOfWork = null)
{
// Get logon message
string message = null;
string reason;
if (pageContext.Parameters.TryGetValue("reason", out reason))
{
switch (reason)
{
case "resetpassword":
message = AuthenticationResource.ResetPasswordLogonMessage;
break;
case "changepassword":
message = AuthenticationResource.ChangePasswordLogonMessage;
break;
case "updateprofile":
message = AuthenticationResource.UpdateUserLogonMessage;
break;
case "confirmusersetpassword":
message = AuthenticationResource.ConfirmUserSetPasswordLogonMessage;
break;
case "confirmuser":
message = AuthenticationResource.ConfirmUserLogonMessage;
break;
}
}
// Return logon user content
return(new LogonUserContent
{
LogonMessage = message,
PartialViewName = "LogonUser"
});
}
/// <summary>
/// Gets element details.
/// </summary>
/// <param name="tenantId">Identifies the tenant that element belongs to.</param>
/// <param name="elementTypeId">The type of the element.</param>
/// <param name="elementId">Identifies the element to return.</param>
/// <param name="unitOfWork">Unit of work.</param>
/// <returns>Element settings (or null if element not found).</returns>
public IElementSettings Read(long tenantId, Guid elementTypeId, long elementId, IUnitOfWork unitOfWork = null)
{
// Construct instance of element settings
IBasicElementService customElementService = _elementFactory.GetElementService(elementTypeId);
IElementSettings settings = customElementService.New(tenantId);
// Populate element ID
settings.ElementId = elementId;
// Populate for advanced elements
if (customElementService is IAdvancedElementService)
{
// Populate element with common settings
_elementRepository.Read(settings, unitOfWork);
// Populate with custom settings
((IAdvancedElementService)customElementService).Read(settings, unitOfWork);
}
// Return fully populated element
return(settings);
}
