public static ContentViewModel Get(string path, UserContext.UserContextName userContext)
{
var item = Load().FirstOrDefault(x => x.ViewModel.Content.Path.Equals(path, StringComparison.CurrentCultureIgnoreCase) &&
(x.ViewModel.Content.UserContext & userContext) != 0);
return(item == null ? null : item.ViewModel);
}
public static void Remove(string path, UserContext.UserContextName userContext)
{
var cache = Load();
cache.RemoveAll(x => x.ViewModel.Content.Path.Equals(path, StringComparison.CurrentCultureIgnoreCase) &&
(x.ViewModel.Content.UserContext & userContext) != 0);
Save(cache);
}
public static AddEditContentViewModel Populate(this AddEditContentViewModel model, string path,
UserContext.UserContextName contextName, int version, ProviderPortalEntities db, UserContext.UserContextInfo userContext)
{
var content = new ContentViewModel();
model = content.Populate(path, contextName, version, db, userContext).Content;
var availableContexts = GetAvailableContexts(path, db);
model.ContextsInUse = UserContext.UserContextName.All ^ availableContexts;
return(model);
}
public ActionResult Edit(string id = null, int version = 0,
UserContext.UserContextName context = UserContext.UserContextName.None)
{
if (id == null)
{
return(RedirectToAction("Create"));
}
var model = new AddEditContentViewModel();
model = model.Populate(id, context, version, db, userContext);
if (model == null)
{
return(HttpNotFound());
}
return(View(model));
}
/// <summary>
/// Get the configuration setting key that defines the user roles available in the current context.
/// </summary>
/// <returns>The configuration setting name.</returns>
private static string GetContextRolesKey()
{
UserContext.UserContextName context = UserContext.GetUserContext().ContextName;
string contextRolesKey = null;
switch (context)
{
case UserContext.UserContextName.Provider:
contextRolesKey = "ProviderContextCanAddRoles";
break;
case UserContext.UserContextName.Organisation:
contextRolesKey = "OrganisationContextCanAddRoles";
break;
case UserContext.UserContextName.Administration:
contextRolesKey = "AdminContextCanAddRoles";
break;
}
return(contextRolesKey);
}
public ActionResult Display(string id = null, int version = 0,
UserContext.UserContextName context = UserContext.UserContextName.None,
bool safeEmbed = false)
{
var model = new ContentViewModel {
SafeEmbed = safeEmbed
};
model = model.Populate(id, context, version, db, userContext);
switch (model.Status)
{
case ContentStatus.NotFound:
return(HttpNotFound());
case ContentStatus.AuthenticationRequired:
return(new HttpUnauthorizedResult());
default:
return(View("Display", model));
}
}
public static ContentViewModel Populate(this ContentViewModel model, string path,
UserContext.UserContextName contextName, int version, ProviderPortalEntities db,
UserContext.UserContextInfo userContext)
{
model = model.PopulateInner(path, contextName, version, db, userContext);
// Safely embed if required to prevent infinite recursion
if (model.SafeEmbed && model.Status != ContentStatus.ExistingPage)
{
return(new ContentViewModel
{
Status = ContentStatus.ExistingPage,
Content = new AddEditContentViewModel
{
Path = path,
Embed = true,
UserContext = userContext.ContextName
},
SafeEmbed = model.SafeEmbed
});
}
return(model);
}
/// <summary>
/// Go through all the published pages for the specified path and
/// archive the content or update its availability as appropriate.
/// </summary>
/// <param name="db">The database.</param>
/// <param name="contentId">The content identifier.</param>
/// <param name="path">The path.</param>
/// <param name="context">The context.</param>
private static void EnsureContextAvailability(ProviderPortalEntities db, int contentId, string path, UserContext.UserContextName context)
{
var pages =
db.Contents.Where(
x =>
x.RecordStatusId == (int)Constants.RecordStatus.Live &&
x.Path.Equals(path, StringComparison.CurrentCultureIgnoreCase) &&
x.UserContext != (int)UserContext.UserContextName.None &&
x.ContentId != contentId);
if (!pages.Any())
{
return;
}
var userContext = (int)context;
foreach (var page in pages)
{
// User context is a flag enumeration so we can use
// bitwise arithmetic to manipulate the values.
// Clear all bits that
var newContext = (userContext ^ page.UserContext) & page.UserContext;
if (newContext == (int)UserContext.UserContextName.None)
{
page.RecordStatusId = (int)Constants.RecordStatus.Archived;
}
else
{
page.UserContext = newContext;
}
}
}
public static bool ContextInUse(this AddEditContentViewModel model, UserContext.UserContextName context)
{
return((model.ContextsInUse & context) != 0);
}
private static ContentViewModel PopulateInner(this ContentViewModel model, string path,
UserContext.UserContextName contextName, int version, ProviderPortalEntities db,
UserContext.UserContextInfo userContext)
{
bool canManageContent = Permission.HasPermission(false, true, Permission.PermissionName.CanManageContent);
version = canManageContent ? version : PublishedVersion;
contextName = canManageContent && contextName != UserContext.UserContextName.None
? contextName
: userContext.ContextName;
if (String.IsNullOrWhiteSpace(path))
{
return(new ContentViewModel {
Content = null, Status = ContentStatus.NotFound
});
}
var cachedVersion = version == PublishedVersion
? ContentCache.Get(path, contextName)
: null;
if (cachedVersion != null)
{
return(cachedVersion);
}
var query = db.Contents.Where(x =>
x.Path.Equals(path, StringComparison.CurrentCultureIgnoreCase))
.AsQueryable();
var content = version == PublishedVersion
? query.FirstOrDefault(x => x.RecordStatusId == (int)Constants.RecordStatus.Live && ((int)contextName & x.UserContext) != 0)
: query.FirstOrDefault(x => x.Version == version);
// No content exists for the current user context return an error
if (content == null && !canManageContent)
{
return(new ContentViewModel
{
Content = null,
Status = query.Any() && !HttpContext.Current.Request.IsAuthenticated
? ContentStatus.AuthenticationRequired
: ContentStatus.NotFound,
SafeEmbed = model.SafeEmbed
});
}
var otherAvailableContexts = UserContext.UserContextName.None;
if (canManageContent)
{
// Work out what other contexts the content is available in
var availableContexts = query
.Where(x => x.RecordStatusId == (int)Constants.RecordStatus.Live)
.Select(x => new { x.ContentId, x.UserContext }).ToList();
foreach (var item in availableContexts)
{
if (content == null || content.ContentId != item.ContentId)
{
otherAvailableContexts |= (UserContext.UserContextName)item.UserContext;
}
}
otherAvailableContexts ^= content == null
? UserContext.UserContextName.None
: (UserContext.UserContextName)content.UserContext;
// The page doesn't exist, offer to create a new one
if (content == null)
{
var defaultContent = db.Contents.FirstOrDefault(x => x.Path == "DefaultContent") ?? new Content();
return(new ContentViewModel
{
Content = new AddEditContentViewModel
{
Version = 1,
Path = path,
Title = defaultContent.Title,
Body = defaultContent.Body,
Scripts = defaultContent.Scripts,
Styles = defaultContent.Styles,
Summary = null,
UserContext = UserContext.UserContextName.All ^ otherAvailableContexts,
Embed = false,
RecordStatusId = (int)Constants.RecordStatus.Pending,
LanguageId = defaultContent.LanguageId,
ContextsInUse = otherAvailableContexts
},
Status = ContentStatus.NewPage,
SafeEmbed = model.SafeEmbed
});
}
}
// Page exists and isn't new
var result = new ContentViewModel
{
Content = new AddEditContentViewModel
{
ContentId = content.ContentId,
Version = content.Version,
Path = content.Path,
Title = content.Title,
Body = content.Body,
Scripts = content.Scripts,
Styles = content.Styles,
Summary = null,
UserContext = (UserContext.UserContextName)content.UserContext,
Embed = content.Embed,
RecordStatusId = content.RecordStatusId,
LanguageId = content.LanguageId,
ContextsInUse = otherAvailableContexts
},
Status = ContentStatus.ExistingPage,
SafeEmbed = model.SafeEmbed
};
if (result.Content.ContentId != 0 && version == PublishedVersion)
{
ContentCache.Add(result);
}
return(result);
}
