/// <summary>
/// Saves the home page model into the database.
/// </summary>
public SaveResult SaveHomePageModel(HomePageModel model)
{
try
{
ContentManagementDb db = new ContentManagementDb();
DomainHomePage homePage = db.DomainHomePages.Find(UserSession.Current.DomainId);
if (homePage == null)
{
homePage = db.DomainHomePages.CreateAdd();
homePage.DomainId = UserSession.Current.DomainId;
}
homePage.ModelType = model.HomePageTemplate;
homePage.HomePage = JsonConvert.SerializeObject(model.HomePageTemplateModel);
db.SaveChanges();
return(SaveResult.Success);
}
catch
{
return(SaveResult.Fail);
}
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Private Methods
/// <summary>
/// Creates a new row in the database.
/// </summary>
private SaveResult CreateBlog(BlogPostModel model, ContentManagementDb db)
{
try
{
BlogPost blog = db.Blogs.CreateAdd();
blog.Initialise();
blog.BlogPostContent = new List <BlogPostContent>();
AutoMap.Map(model, blog);
blog.CreatedByUserId = UserSession.Current.UserId;
blog.DomainId = UserSession.Current.DomainId;
BlogPostContent blogContent = new BlogPostContent();
AutoMap.Map(model, blogContent);
blog.BlogPostContent.Add(blogContent);
blogContent.Initialize();
blogContent.LastEditedByUserId = blog.CreatedByUserId;
SetPublishStatus(blog, blogContent, model.Publish);
db.SaveChanges();
return(SaveResult.Success);
}
catch
{
return(SaveResult.Fail);
}
}
/// <summary>
/// Creates a select list of the navigation pages.
/// </summary>
/// <param name="selected">The currently selected navigation page id.</param>
public static List <SelectListItem> Pages(int?selected)
{
List <SelectListItem> selectList = new List <SelectListItem>();
ContentManagementDb db = new ContentManagementDb();
List <IGrouping <int, PageContent> > pages = db.PageContent.Where(s => s.Page.DomainId == UserCookie.Current.DomainId && (s.PublishStatus == PublishStatus.Published || s.PublishStatus == PublishStatus.Draft))
.GroupBy(s => s.PageId)
.ToList();
foreach (IGrouping <int, PageContent> page in pages)
{
PageContent pageContent = page.FirstOrDefault(s => s.PublishStatus == PublishStatus.Published);
if (pageContent == null)
{
pageContent = page.First();
}
selectList.Add(new SelectListItem()
{
Text = pageContent.Title,
Value = pageContent.PageId.ToString(),
Selected = pageContent.PageId == selected
});
}
return(selectList);
}
/// <summary>
/// Creates a new user cookie based off any known information in the current http context.
/// </summary>
/// <param name="context">The current http context.</param>
private UserCookie(HttpContext context)
{
NavItems = new List <NavItem>();
ContentManagementDb db = new ContentManagementDb();
Domain domain = Domain.FindMatchedDomain(context.Request.Url, db);
if (context.User.Identity.Name == string.Empty)
{
if (domain != null)
{
Initialise(db, domain);
}
return;
}
UserProfile user = db.Users.FirstOrDefault(u => u.UserName == context.User.Identity.Name);
if (user != null)
{
if (domain != null)
{
Initialise(db, domain, user);
}
}
UserSession.CreateInstance(user, domain);
}
/// <summary>
/// Retrieves the page template model.
/// </summary>
/// <param name="pageId">The page id to get the model for.</param>
/// <param name="status">The publish status version to get the page for.</param>
/// <param name="name">Holds the name of the model type that was retrieved.</param>
/// <returns>Retrieves the requested page template.</returns>
public PageTemplate RetrievePage(int pageId, PublishStatus status, out string name)
{
ContentManagementDb db = new ContentManagementDb();
Page entity = db.Pages.Include(s => s.PageContent).FirstOrDefault(s => s.PageId == pageId);
return(RetrievePage(entity, status, out name));
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Public Methods
public override void InitialiseForDisplay()
{
ContentManagementDb db = new ContentManagementDb();
int pageNumber = 0;
if (base.Request.QueryString.AllKeys.Contains("page") && int.TryParse(base.Request.QueryString["page"], out pageNumber))
{
if (pageNumber < 1)
{
pageNumber = 1;
}
--pageNumber;
}
var query = db.BlogPostContent.Include(s => s.Blog)
.Include(s => s.PublishedByUser)
.Where(s => s.PublishStatus == PublishStatus.Published && s.Blog.DomainId == UserSession.Current.DomainId && s.Blog.IsDeleted == false)
.OrderByDescending(s => s.Blog.UTCDateCreated)
.Skip(pageNumber * this.MaxNumberOfPosts);
this.PageNumberIndex = pageNumber;
this.HasPreviousPage = (pageNumber > 0);
this.HasNextPage = query.Count() > this.MaxNumberOfPosts;
this.BlogPosts = query.Take(this.MaxNumberOfPosts)
.ToList();
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Private Methods
/// <summary>
/// Creates a new row in the database.
/// </summary>
private SaveResult CreateNavItem(NavigationModel model, ContentManagementDb db)
{
try
{
DomainNavigationItem navItem = new DomainNavigationItem();
navItem.Initialise();
AutoMap.Map(model, navItem);
int domainId = UserSession.Current.DomainId;
navItem.DomainId = domainId;
navItem.Ordinal = db.DomainNavigationItems.Where(s => s.DomainId == domainId && s.IsDeleted == false).Select(s => s.Ordinal).Max() + 1;
db.DomainNavigationItems.Add(navItem);
db.SaveChanges();
return(SaveResult.Success);
}
catch
{
return(SaveResult.Fail);
}
}
/// <summary>
/// Creates a new user cookie based off an existing cookie and a known domain.
/// </summary>
/// <param name="cookie">The existing cookie.</param>
/// <param name="domain">The current domain.</param>
/// <param name="db">A reference to an existing database connection.</param>
private UserCookie(UserCookie cookie, Domain domain, ContentManagementDb db)
{
NavItems = new List <NavItem>();
UserProfile user = db.Users.FirstOrDefault(u => u.UserId == UserSession.Current.UserId);
Initialise(db, domain, user);
}
public SelectList GetRootNavItems()
{
ContentManagementDb db = new ContentManagementDb();
List <DomainNavigationItem> navItems = db.DomainNavigationItems.Where(s => s.DomainId == _domainId && s.IsDeleted == false && s.ParentDomainNavigationItemId == null).ToList();
return(new SelectList(navItems, "DomainNavigationItemId", "Title", ParentDomainNavigationItemId));
}
public JsonResult Uploads(string term)
{
ContentManagementDb db = new ContentManagementDb();
term = (term ?? "").ToLower();
var uploads = db.Uploads.Where(s => s.DomainId == UserSession.Current.DomainId && s.Title.ToLower().Contains(term)).Take(10);
return(Json(new { uploads = uploads.Select(s => new { uploadId = s.UploadId, fileLocation = s.PhysicalLocation, title = s.Title }) }));
}
/// <summary>
/// Creates a new user cookie based off a known domain and a possibly known user.
/// </summary>
/// <param name="db">A reference to an existing database connection.</param>
/// <param name="domain">The current domain.</param>
/// <param name="user">The current possible user.</param>
private void Initialise(ContentManagementDb db, Domain domain, UserProfile user = null)
{
DomainId = domain.DomainId;
SiteName = domain.Name;
Theme = domain.Theme;
LastUpdated = domain.DateUpdated;
if (domain.BackgroundUpload != null)
{
BackgroundUrl = domain.BackgroundUpload.PhysicalLocation;
}
if (domain.LogoUpload != null)
{
LogoUrl = domain.LogoUpload.PhysicalLocation;
}
if (user != null)
{
UserId = user.UserId;
Role = user.Role;
}
else
{
Role = ContentManagementSystemDatabase.Role.GeneralUser;
}
IQueryable <DomainNavigationItem> menuItems;
if (IsLoggedIn)
{
menuItems = db.DomainNavigationItems;
}
else
{
menuItems = db.DomainNavigationItems.Include(s => s.Page);
}
menuItems = menuItems.Include(s => s.SubNavigationItems)
.Where(d => d.DomainId == DomainId && d.ParentDomainNavigationItemId == null)
.WhereActive();
if (this.IsLoggedIn == false)
{
menuItems = menuItems.Where(m => m.Page.RequiresLogin == false);
}
NavItems = menuItems.OrderBy(d => d.Ordinal)
.ToList()
.Select(s => new NavItem(s))
.ToList();
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Public Methods
public override void InitialiseForDisplay()
{
ContentManagementDb db = new ContentManagementDb();
this.SubNavigationItems = db.DomainNavigationItems.WhereActive().Where(s => s.DomainId == _domainId && s.IsDeleted == false && s.ParentDomainNavigationItemId == NavigationItemId).ToList();
//this.BlogPosts = db.BlogPostContent.Include( s => s.Blog )
// .Where( s => s.PublishStatus == PublishStatus.Published && s.Blog.DomainId == UserSession.Current.DomainId && s.Blog.IsDeleted == false )
// .OrderByDescending( s => s.Blog.UTCDateCreated )
// .Take( this.MaxNumberOfPosts )
// .ToList();
}
/// <summary>
/// Creates a new user cookie based off the provided user and the current http context.
/// </summary>
/// <param name="user">The user to create this cookie for.</param>
/// <param name="context">The current http context.</param>
private UserCookie(UserProfile user, HttpContextBase context)
{
NavItems = new List <NavItem>();
ContentManagementDb db = new ContentManagementDb();
Domain domain = Domain.FindMatchedDomain(context.Request.Url, db);
Initialise(db, domain, user);
UserSession.CreateInstance(user, domain);
}
/// <summary>
/// Saves the blog post into the database.
/// </summary>
public SaveResult SaveBlogPost(BlogPostModel model)
{
ContentManagementDb db = new ContentManagementDb();
BlogPost blog = db.Blogs.Find(model.BlogId);
if (blog == null)
{
return(CreateBlog(model, db));
}
return(UpdateBlog(blog, model, db));
}
/// <summary>
/// Saves the page model into the database.
/// </summary>
public SaveResult SavePage(PageModel model)
{
ContentManagementDb db = new ContentManagementDb();
Page page = db.Pages.Find(model.PageId);
if (page == null)
{
return(CreatePage(model, db));
}
return(UpdatePage(page, model, db));
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Class Members
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Constructors/Initialisation
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Public Methods
/// <summary>
/// Gets the model for the home page of the current domain.
/// </summary>
public HomePageModel GetHomePageModel()
{
ContentManagementDb db = new ContentManagementDb();
HomePageModel model = new HomePageModel();
string name;
model.HomePageTemplateModel = base.RetrieveHomePage(out name);
model.HomePageTemplate = name;
return(model);
}
/// <summary>
/// Saves the navigation item into the database.
/// </summary>
public SaveResult SaveNavigationItem(NavigationModel model)
{
ContentManagementDb db = new ContentManagementDb();
DomainNavigationItem navItem = db.DomainNavigationItems.Find(model.DomainNavigationItemId);
if (navItem == null)
{
return(CreateNavItem(model, db));
}
return(UpdateNavItem(navItem, model, db));
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Class Members
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Constructors/Initialisation
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Public Methods
/// <summary>
/// Gets the navigation item from the database.
/// </summary>
public NavigationModel GetNavigationModel(int?navItemId)
{
ContentManagementDb db = new ContentManagementDb();
DomainNavigationItem navItem = db.DomainNavigationItems.Find(navItemId);
if (navItem == null)
{
return(new NavigationModel());
}
return(new NavigationModel(navItem));
}
public SaveResult SaveDomainSettings(DomainModel model)
{
ContentManagementDb db = new ContentManagementDb();
Domain domain = db.Domains.Find(UserSession.Current.DomainId);
AutoMap.Map(model, domain);
domain.UpdateTimeStamp();
db.SaveChanges();
return(SaveResult.Success);
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Private Methods
private void FillItemsWithUploads()
{
List <int> uploadIds = this.Items.Select(s => s.UploadId).Distinct().ToList();
ContentManagementDb db = new ContentManagementDb();
Dictionary <int, Upload> uploads = new Dictionary <int, Upload>();
db.Uploads.Join(uploadIds, o => o.UploadId, i => i, (o, i) => new { Key = i, Value = o }).ToList().ForEach(s => uploads.Add(s.Key, s.Value));
foreach (TileGalleryItem item in this.Items)
{
item.UpdateUploadEntity(uploads[item.UploadId]);
}
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Class Members
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Constructors/Initialisation
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Public Methods
/// <summary>
/// Gets the blog post from the database.
/// </summary>
public BlogPostModel GetBlogPostModel(int?blogPostId)
{
if (blogPostId.HasValue == false)
{
return(new BlogPostModel());
}
ContentManagementDb db = new ContentManagementDb();
BlogPost blogPost = db.Blogs.Find(blogPostId);
if (blogPost == null)
{
return(new BlogPostModel());
}
return(new BlogPostModel(blogPost));
}
public override void OnBeforeSave()
{
base.OnBeforeSave();
List <int> uploadIds = this.NavigationItems.Select(s => s.UploadId).ToList();
ContentManagementDb db = new ContentManagementDb();
List <Upload> uploads = db.Uploads.Join(uploadIds, o => o.UploadId, i => i, (o, i) => o).ToList();
foreach (ImageNavigationItem item in this.NavigationItems)
{
Upload upload = uploads.First(s => s.UploadId == item.UploadId);
item.ImageUrl = upload.PhysicalLocation;
item.NavigationUrl = "page/" + item.PageId;
}
}
public ActionResult Login(LoginModel model, string returnUrl)
{
if (ModelState.IsValid && WebSecurity.Login(model.UserName, model.Password, persistCookie: model.RememberMe))
{
int userId = WebSecurity.GetUserId(model.UserName);
ContentManagementDb db = new ContentManagementDb();
UserProfile user = db.Users.FirstOrDefault(u => u.UserId == userId);
user.LastLogin = DateTime.Now;
db.SaveChangesAsync();
UserCookie.CreateInstance(user, HttpContext);
return(RedirectToLocal(returnUrl));
}
// If we got this far, something failed, redisplay form
ModelState.AddModelError("", "The user name or password provided is incorrect.");
return(View(model));
}
/// <summary>
/// Updates an existing row in the database.
/// </summary>
private SaveResult UpdatePage(Page page, PageModel model, ContentManagementDb db)
{
if (UserSession.Current.IsAdministrator == false)
{
return(SaveResult.AccessDenied);
}
if (UserSession.Current.CurrentDomain().CanAccess(page) == false)
{
return(SaveResult.IncorrectDomain);
}
try
{
PageContent pageContent = page.PageContent.FirstOrDefault(s => s.PublishStatus == PublishStatus.Draft);
if (pageContent == null)
{
pageContent = new PageContent();
page.PageContent.Add(pageContent);
}
AutoMap.Map(model, pageContent);
UpdateWithPageModel(pageContent, model);
page.UpdateTimeStamp();
pageContent.UpdateTimeStamp();
pageContent.LastEditedByUserId = UserSession.Current.UserId;
SetPublishStatus(page, pageContent, model.Publish);
db.SaveChanges();
return(SaveResult.Success);
}
catch (Exception ex)
{
ErrorLog.Error("Could not update page", ex);
return(SaveResult.Fail);
}
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Public Methods
public override void PrepareForDisplay()
{
List <int> uploadIds = Slides.Select(s => s.UploadId).ToList();
List <int> pageIds = Slides.Where(s => s.PageId.HasValue).Select(s => s.PageId.Value).ToList();
ContentManagementDb db = new ContentManagementDb();
List <Upload> uploads = db.Uploads.Where(s => uploadIds.Contains(s.UploadId)).ToList();
List <ContentManagementSystemDatabase.Page> pages = db.Pages.Where(s => pageIds.Contains(s.PageId)).ToList();
foreach (Upload upload in uploads)
{
Slides.Where(s => s.UploadId == upload.UploadId).ToList().ForEach(s => s.ImgUrl = upload.PhysicalLocation);
}
foreach (ContentManagementSystemDatabase.Page page in pages)
{
Slides.Where(s => s.PageId == page.PageId).ToList().ForEach(s => s.PageUrl = page.PageUrl());
}
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Public Methods
public SelectList GetAvailablePages()
{
ContentManagementDb db = new ContentManagementDb();
List <PageContent> pages = db.Pages.Include(s => s.PageContent)
.Where(s => s.DomainId == _domainId && s.IsDeleted == false)
.SelectMany(s => s.PageContent)
.Where(s => s.PublishStatus != PublishStatus.Deleted && s.PublishStatus != PublishStatus.OutOfDate)
.ToList();
List <int> pageIds = pages.Select(s => s.PageId).ToList();
List <PageContent> displayPages = pages.Where(s => pageIds.Contains(s.PageId) && s.PublishStatus == PublishStatus.Published).ToList();
List <int> usedPageIds = displayPages.Select(s => s.PageId).ToList();
pageIds.RemoveAll(s => usedPageIds.Contains(s));
displayPages.AddRange(pages.Where(s => pageIds.Contains(s.PageId) && s.PublishStatus == PublishStatus.Draft));
return(new SelectList(displayPages, "PageId", "Title", PageId));
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Class Members
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Constructors/Initialisation
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Public Methods
public void SendEmail()
{
MailMessage message = new MailMessage();
Domain domain = new ContentManagementDb().Domains.Find(UserSession.Current.DomainId);
if (string.IsNullOrEmpty(domain.EmailAddress))
{
return;
}
message.To.Add(domain.EmailAddress);
message.From = new MailAddress(this.EmailAddress);
message.Subject = "Online Enquiry";
message.Body = this.Enquiry;
using (SmtpClient smtp = new SmtpClient())
{
smtp.Send(message);
}
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Private Methods
/// <summary>
/// Creates a new row in the database.
/// </summary>
private SaveResult CreateNavItem(NavigationModel model, ContentManagementDb db)
{
try
{
DomainNavigationItem navItem = new DomainNavigationItem();
navItem.Initialise();
AutoMap.Map(model, navItem);
navItem.DomainId = UserSession.Current.DomainId;
db.DomainNavigationItems.Add(navItem);
db.SaveChanges();
return(SaveResult.Success);
}
catch
{
return(SaveResult.Fail);
}
}
/// <summary>
/// Updates an existing row in the database.
/// </summary>
private SaveResult UpdateBlog(BlogPost blog, BlogPostModel model, ContentManagementDb db)
{
if (UserSession.Current.IsAdministrator == false)
{
return(SaveResult.AccessDenied);
}
if (UserSession.Current.CurrentDomain().CanAccess(blog) == false)
{
return(SaveResult.IncorrectDomain);
}
try
{
BlogPostContent pageContent = blog.BlogPostContent.FirstOrDefault(s => s.PublishStatus == PublishStatus.Draft);
if (pageContent == null)
{
pageContent = new BlogPostContent();
blog.BlogPostContent.Add(pageContent);
}
AutoMap.Map(model, pageContent);
blog.UpdateTimeStamp();
pageContent.UpdateTimeStamp();
pageContent.LastEditedByUserId = UserSession.Current.UserId;
SetPublishStatus(blog, pageContent, model.Publish);
db.SaveChanges();
return(SaveResult.Success);
}
catch
{
return(SaveResult.Fail);
}
}
/* ---------------------------------------------------------------------------------------------------------- */
#region Class Members
#endregion
/* ---------------------------------------------------------------------------------------------------------- */
#region Constructors/Initialisation
/// <summary>
/// Creates a new user session based off the current http context.
/// </summary>
/// <param name="context">The current http context.</param>
private UserSession(HttpContext context)
{
ContentManagementDb db = new ContentManagementDb();
Domain domain = Domain.FindMatchedDomain(context.Request.Url, db);
if (context.User.Identity.Name == string.Empty)
{
if (domain != null)
{
Initialise(domain);
}
return;
}
UserProfile user = db.Users.FirstOrDefault(u => u.UserName == context.User.Identity.Name);
if (user != null && domain != null)
{
Initialise(domain, user);
}
}
