/// <summary>
/// Handles the Load event of the Page control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void Page_Load(object sender, EventArgs e)
{
if (!this.Visible)
{
return;
}
if (!IsPostBack)
{
SaveButton.OnClientClick = String.Format("RunCommand('ChangeTemplate', {0}.value);", TemplateListControl.ClientID);
BindDropDownList();
}
if (Request.QueryString["TemplateId"] != null)
{
// Check permissions, only cms manager can change template
if (!Page.User.Identity.IsAuthenticated || !SecurityManager.CheckPermission(new string[] { CmsRoles.ManagerRole }))
{
this.Visible = false;
return;
}
TemplateListControl.SelectedValue = Request.QueryString["TemplateId"];
}
using (IDataReader reader = PageVersion.GetVersionById(VersionId))
{
if (reader.Read())
{
TemplateListControl.SelectedValue = ((int)reader["TemplateId"]).ToString();
TemplateListControl.Visible = true;
//statusId = (int)reader["statusId"];
}
}
}
/// <summary>
/// Maps the basic properties on a PageRenderDetails.
/// </summary>
/// <remarks>
/// This isn't a very fully featured map function and will likey
/// be reworked later on.
/// </remarks>
public PageRenderDetails Map(
PageVersion dbPageVersion
)
{
var page = new PageRenderDetails()
{
MetaDescription = dbPageVersion.MetaDescription,
PageId = dbPageVersion.PageId,
PageVersionId = dbPageVersion.PageVersionId,
Title = dbPageVersion.Title,
WorkFlowStatus = (WorkFlowStatus)dbPageVersion.WorkFlowStatusId
};
page.OpenGraph = _openGraphDataMapper.Map(dbPageVersion);
page.Template = _pageTemplateMapper.Map(dbPageVersion.PageTemplate);
page.Regions = dbPageVersion
.PageTemplate
.PageTemplateRegions
.Select(r => new PageRegionRenderDetails()
{
PageTemplateRegionId = r.PageTemplateRegionId,
Name = r.Name
// Blocks mapped elsewhere
})
.ToList();
return(page);
}
private PageDetails Map(
PageVersion dbPageVersion,
ICollection <PageRegionDetails> regions,
PageRoute pageRoute
)
{
var page = new PageDetails();
page.PageId = dbPageVersion.PageId;
page.PageRoute = pageRoute;
page.AuditData = _auditDataMapper.MapCreateAuditData(dbPageVersion.Page);
page.Tags = dbPageVersion
.Page
.PageTags
.Select(t => t.Tag.TagText)
.OrderBy(t => t)
.ToList();
page.LatestVersion = new PageVersionDetails()
{
MetaDescription = dbPageVersion.MetaDescription,
PageVersionId = dbPageVersion.PageVersionId,
ShowInSiteMap = !dbPageVersion.ExcludeFromSitemap,
Title = dbPageVersion.Title,
WorkFlowStatus = (WorkFlowStatus)dbPageVersion.WorkFlowStatusId
};
page.LatestVersion.OpenGraph = _openGraphDataMapper.Map(dbPageVersion);
page.LatestVersion.Template = _pageTemplateMapper.Map(dbPageVersion.PageTemplate);
page.LatestVersion.Regions = regions;
return(page);
}
public async Task GetLatestVersion()
{
// given
PageVersion pageVersion = _fixture.Create <PageVersion>();
int pageId = pageVersion.PageId;
_pageVersionRepositoryMock
.GetLatestVersionAsync(pageId)
.Returns(pageVersion);
// when
PageVersionResponse response = await _pageVersionsController.GetLatestVersion(pageId);
// then
response.ShouldNotBeNull();
response.PageId.ShouldBe(pageId);
response.Text.ShouldBe(pageVersion.Text);
_pageVersionRepositoryMock
.Received(1)
.GetLatestVersionAsync(pageId);
_objectsConverterMock
.Received(1)
.ConvertToPageVersionResponse(pageVersion);
}
public async Task Add()
{
// given
int pageId = 1;
string text = "text";
string author = "author";
DateTime dateTime = DateTime.UtcNow;
var repoPageVersion = new PageVersion()
{
PageId = pageId,
DateTime = dateTime,
Author = author,
Text = text
};
_pageVersionRepositoryMock
.AddNewVersionAsync(pageId, text, author, dateTime)
.Returns(repoPageVersion);
// when
PageVersionResponse actualResponse = await _pageVersionsController.Add(pageId, text, author, dateTime);
// then
actualResponse.PageId.ShouldBe(pageId);
actualResponse.Text.ShouldBe(text);
actualResponse.Author.ShouldBe(author);
actualResponse.DateTime.ShouldBe(dateTime);
await _pageVersionRepositoryMock
.Received(1)
.AddNewVersionAsync(pageId, text, author, dateTime);
}
public async Task CreateNewVersionAsync(Guid pageId)
{
PageVersion newVersion;
var currentVersion = await(from v in db.PageVersions
where v.PageId == pageId
orderby v.RevisionNumber descending
select v).FirstOrDefaultAsync();
if (currentVersion == null)
{
newVersion = new PageVersion
{
PageVersionId = Guid.NewGuid(),
PageId = pageId,
RevisionNumber = 1,
Status = PageVersionStatus.Draft
};
}
else
{
newVersion = new PageVersion
{
PageVersionId = Guid.NewGuid(),
PageId = pageId,
RevisionNumber = currentVersion.RevisionNumber + 1,
Status = PageVersionStatus.Draft,
Body = currentVersion.Body,
Title = currentVersion.Title,
MetaDescription = currentVersion.MetaDescription
};
}
db.PageVersions.Add(newVersion);
await db.SaveChangesAsync();
}
public async Task GetById()
{
// given
PageVersion pageVersion = _fixture.Create <PageVersion>();
Guid versionId = pageVersion.Id;
_pageVersionRepositoryMock
.GetByIdAsync(versionId)
.Returns(pageVersion);
// when
PageVersionResponse actualResponse = await _pageVersionsController.GetById(versionId);
// then
actualResponse.ShouldNotBeNull();
actualResponse.Id.ShouldBe(versionId);
await _pageVersionRepositoryMock
.Received(1)
.GetByIdAsync(versionId);
_objectsConverterMock
.Received(1)
.ConvertToPageVersionResponse(pageVersion);
}
public async Task Add()
{
// given
int pageId = 1;
string text = "text";
string author = "author";
DateTime dateTime = DateTime.UtcNow;
var repoPageVersion = new PageVersion()
{
PageId = pageId,
DateTime = dateTime,
Author = author,
Text = text
};
_pageVersionRepositoryMock
.AddNewVersionAsync(pageId, text, author, dateTime)
.Returns(repoPageVersion);
// when
ActionResult <PageVersionResponse> actionResult = await _pageVersionsController.Add(pageId, text, author, dateTime);
// then
actionResult.ShouldBeCreatedAtActionResult();
PageVersionResponse response = actionResult.CreatedAtActionResultValue();
response.PageId.ShouldBe(pageId);
response.Text.ShouldBe(text);
response.Author.ShouldBe(author);
response.DateTime.ShouldBe(dateTime);
}
public async Task Update()
{
// given
var request = new PageVersionRequest()
{
Id = Guid.NewGuid(),
Author = "buxton",
DateTime = DateTime.Today,
PageId = 42,
Text = "Some new text"
};
var pageVersion = new PageVersion()
{
Id = request.Id,
Author = request.Author,
DateTime = request.DateTime,
PageId = request.PageId,
Text = request.Text,
};
_objectsConverterMock
.ConvertToPageVersion(request)
.Returns(pageVersion);
_pageVersionRepositoryMock
.UpdateExistingVersionAsync(pageVersion)
.Returns(Task.CompletedTask);
// when
ActionResult <string> actionResult = await _pageVersionsController.Update(request);
// then
actionResult.ShouldBeNoContentResult();
}
private SearchResultView Create(Document document, ScoreDoc scoreDoc)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
if (scoreDoc == null)
{
throw new ArgumentNullException(nameof(scoreDoc));
}
EnsureFieldsExist(document);
var createdOn = DateTime.UtcNow;
if (!DateTime.TryParse(document.GetField("createdon").StringValue, out createdOn))
{
createdOn = DateTime.UtcNow;
}
var title = document.GetField("title").StringValue;
return(new SearchResultView
{
ContentLength = int.Parse(document.GetField("contentlength").StringValue),
ContentSummary = document.GetField("contentsummary").StringValue,
CreatedBy = document.GetField("createdby").StringValue,
CreatedOn = createdOn,
Id = int.Parse(document.GetField("id").StringValue),
Score = scoreDoc.Score,
Tags = PageVersion.SplitTags(document.GetField("tags").StringValue),
Title = title
});
}
private async Task CreateHomepage()
{
// Create a homepage with text through repositories as it's simpler
string createdBy = "editor";
DateTime createdOn = DateTime.Today;
PageRepository repository = CreatePageRepository();
Page page = _fixture.Create <Page>();
page.Id = -1; // should be reset
page.CreatedBy = createdBy;
page.CreatedOn = createdOn;
page.LastModifiedBy = createdBy;
page.LastModifiedOn = createdOn;
page.Tags = "homepage";
Page newPage = await repository.AddNewPageAsync(page);
_outputHelper.WriteLine($"Created homepage - id: {page.Id}");
PageVersionRepository pageRepository = CreatePageVersionRepository();
PageVersion pageVersion = await pageRepository.AddNewVersionAsync(newPage.Id, "## This is some markdown\nAnd some **bold** text", "editor");
_outputHelper.WriteLine($"Created homepage version - id: {pageVersion.Id}");
}
public void ConvertToPageVersion()
{
var pageVersionRequest = _fixture.Create <PageVersionRequest>();
PageVersion pageVersion = _converter.ConvertToPageVersion(pageVersionRequest);
pageVersion.ShouldHaveSamePropertyValuesAs(pageVersionRequest);
}
/// <summary>
/// Handles the Load event of the Page control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
protected void Page_Load(object sender, EventArgs e)
{
DataView dvVersions = PageVersion.GetVersionByLangIdDT(PageId, LanguageId).DefaultView;
grdMain.DataSource = dvVersions;
grdMain.DataBind();
}
public async Task <ActionResult <string> > Update(PageVersionRequest pageVersionRequest)
{
// doesn't add a new version
PageVersion pageVersion = _objectsConverter.ConvertToPageVersion(pageVersionRequest);
await _pageVersionRepository.UpdateExistingVersionAsync(pageVersion);
return(NoContent());
}
public async Task <ActionResult <PageVersionResponse> > Get(Guid id)
{
PageVersion pageVersion = await _pageVersionRepository.GetByIdAsync(id);
PageVersionResponse responses = _objectsConverter.ConvertToPageVersionResponse(pageVersion);
return(Ok(responses));
}
public async Task UpdateExistingVersionAsync(PageVersion version)
{
using (var session = _store.LightweightSession())
{
session.Store(version);
await session.SaveChangesAsync();
}
}
public async Task <ActionResult <PageVersionResponse> > Add(int pageId, string text, string author, DateTime?dateTime = null)
{
PageVersion pageVersion = await _pageVersionRepository.AddNewVersionAsync(pageId, text, author, dateTime);
PageVersionResponse response = _objectsConverter.ConvertToPageVersionResponse(pageVersion);
return(CreatedAtAction(nameof(Add), response));
}
private async Task <Page> MapPage(AddPageCommand command, IExecutionContext executionContext)
{
// Create Page
var page = new Page();
page.PageTypeId = (int)command.PageType;
page.Locale = GetLocale(command.LocaleId);
page.PageDirectory = await GetPageDirectoryAsync(command.PageDirectoryId);
_entityAuditHelper.SetCreated(page, executionContext);
_entityTagHelper.UpdateTags(page.PageTags, command.Tags, executionContext);
var pageTemplate = await GetTemplateAsync(command);
if (command.PageType == PageType.CustomEntityDetails)
{
var definition = await GetCustomEntityDefinitionAsync(pageTemplate.CustomEntityDefinitionCode, executionContext);
var rule = await GetAndValidateRoutingRuleAsync(command, definition, executionContext);
page.CustomEntityDefinitionCode = pageTemplate.CustomEntityDefinitionCode;
page.UrlPath = rule.RouteFormat;
}
else
{
page.UrlPath = command.UrlPath;
}
var pageVersion = new PageVersion();
pageVersion.Title = command.Title;
pageVersion.ExcludeFromSitemap = !command.ShowInSiteMap;
pageVersion.MetaDescription = command.MetaDescription ?? string.Empty;
pageVersion.OpenGraphTitle = command.OpenGraphTitle;
pageVersion.OpenGraphDescription = command.OpenGraphDescription;
pageVersion.OpenGraphImageId = command.OpenGraphImageId;
pageVersion.PageTemplate = pageTemplate;
pageVersion.DisplayVersion = 1;
if (command.Publish)
{
page.PublishStatusCode = PublishStatusCode.Published;
page.PublishDate = command.PublishDate ?? executionContext.ExecutionDate;
pageVersion.WorkFlowStatusId = (int)WorkFlowStatus.Published;
}
else
{
page.PublishStatusCode = PublishStatusCode.Unpublished;
page.PublishDate = command.PublishDate;
pageVersion.WorkFlowStatusId = (int)WorkFlowStatus.Draft;
}
_entityAuditHelper.SetCreated(pageVersion, executionContext);
page.PageVersions.Add(pageVersion);
return(page);
}
private Task OnTransactionComplete(PageVersion pageVersion, PageVersionBlock newBlock)
{
_pageCache.Clear(pageVersion.PageId);
return(_messageAggregator.PublishAsync(new PageVersionBlockAddedMessage()
{
PageId = pageVersion.PageId,
PageVersionBlockId = newBlock.PageVersionBlockId
}));
}
private Task OnTransactionComplete(PageVersion draft)
{
_pageCache.Clear(draft.PageId);
return(_messageAggregator.PublishAsync(new PageDraftVersionUpdatedMessage()
{
PageId = draft.PageId,
PageVersionId = draft.PageVersionId
}));
}
public async Task <PageVersionResponse> GetLatestVersion(int pageId)
{
PageVersion latestPageVersion = await _pageVersionRepository.GetLatestVersionAsync(pageId);
if (latestPageVersion == null)
{
return(null);
}
return(_objectsConverter.ConvertToPageVersionResponse(latestPageVersion));
}
private void UpdateDraft(UpdatePageDraftVersionCommand command, PageVersion draft)
{
EntityNotFoundException.ThrowIfNull(draft, "Draft:" + command.PageId);
draft.Title = command.Title;
draft.ExcludeFromSitemap = !command.ShowInSiteMap;
draft.MetaDescription = command.MetaDescription ?? string.Empty;
draft.OpenGraphTitle = command.OpenGraphTitle;
draft.OpenGraphDescription = command.OpenGraphDescription;
draft.OpenGraphImageId = command.OpenGraphImageId;
}
/// <summary>
/// Loads the data and data bind.
/// </summary>
/// <param name="sortExpression">The sort expression.</param>
private void LoadDataAndDataBind(string sortExpression)
{
MyListView.CurrentListView.PrimaryKeyId = EcfListView.MakePrimaryKeyIdString("VersionId");
DataTable dtPV;
dtPV = PageVersion.GetWorkVersionByUserId(Page.User.Identity.Name);
if (dtPV != null && dtPV.Rows.Count > 0)
{
DataView dv = dtPV.DefaultView;
//APPLY FILTER
int DefaultWorkflowId = -1;
using (IDataReader reader = Mediachase.Cms.Workflow.LoadDefault())
{
if (reader.Read())
{
DefaultWorkflowId = (int)reader["WorkflowId"];
}
reader.Close();
}
int PublishId = WorkflowStatus.GetLastByWorkflowId(DefaultWorkflowId);
int DraftId = WorkflowStatus.DraftId;
string filter = Parameters["filter"];
if (!String.IsNullOrEmpty(filter))
{
if (filter.Equals("draft"))
{
dv.RowFilter = String.Format("StateId = 1 AND StatusId = {0}", DraftId);
}
else if (filter.Equals("approve"))
{
dv.RowFilter = String.Format("StateId = 1 AND StatusId NOT IN (-1, {0}, {1})", PublishId, DraftId);
}
else if (filter.Equals("reject"))
{
dv.RowFilter = String.Format("StateId = 2 AND StatusId NOT IN (-1, {0})", PublishId);
}
}
else
{
dv.RowFilter = String.Format("StateId = 1 AND StatusId NOT IN (-1, {0}, {1})", PublishId, DraftId);;
}
//END:APPLY FILTER
dv.Sort = sortExpression;
MyListView.DataSource = dv;
}
MyListView.DataBind();
}
public async Task <ActionResult <PageVersionResponse> > GetLatestVersion(int pageId)
{
PageVersion latestPageVersion = await _pageVersionRepository.GetLatestVersionAsync(pageId);
if (latestPageVersion == null)
{
return(null);
}
PageVersionResponse response = _objectsConverter.ConvertToPageVersionResponse(latestPageVersion);
return(Ok(response));
}
void ProcessApproveCommand(string[] items)
{
for (int i = 0; i < items.Length; i++)
{
string[] keys = EcfListView.GetPrimaryKeyIdStringItems(items[i]);
if (keys != null)
{
int versionId = Int32.Parse(keys[0]);
using (IDataReader reader = PageVersion.GetVersionById(versionId))
{
if (reader.Read())
{
int templateId = (int)reader["TemplateId"];
int statusId = (int)reader["StatusId"];
int stateId = (int)reader["StateId"];
int langId = (int)reader["LangId"];
int newStatus = WorkflowAccess.GetNextStatusId(statusId);
if (newStatus > 0)
{
PageVersion.UpdatePageVersion(versionId, templateId, langId, statusId, newStatus, ProfileContext.Current.UserId, 1, "");
}
//PageVersion.UpdatePageVersion(CMSContext.Current.VersionId, templateId, langId, statusId, WorkflowAccess.GetMaxStatus(Roles.GetRolesForUser(), WorkflowStatus.GetLast(statusId)), (Guid)Membership.GetUser(Page.User.Identity.Name).ProviderUserKey, 1, string.Empty);
// if we publish version
if (newStatus == WorkflowStatus.GetLast(statusId))
{
//find old publishd and put to archive
using (IDataReader reader2 = PageVersion.GetVersionByStatusId((int)reader["PageId"], newStatus))
{
while (reader2.Read())
{
if ((int)reader2["LangId"] == langId)
{
if (versionId != (int)reader2["VersionId"])
{
PageVersion.UpdatePageVersion((int)reader2["VersionId"], (int)reader2["TemplateId"], (int)reader2["LangId"], (int)reader2["StatusId"], WorkflowStatus.GetArcStatus((int)reader2["StatusId"]), ProfileContext.Current.UserId, 2, "sent to archieve");
}
}
}
reader2.Close();
}
}
}
reader.Close();
}
}
}
}
public override void InitializeInstance(PageVersion pageVersion)
{
if (pageVersion == null || string.IsNullOrEmpty(pageVersion.Fields))
{
return;
}
dynamic fields = JObject.Parse(pageVersion.Fields);
MetaTitle = fields.MetaTitle;
MetaKeywords = fields.MetaKeywords;
MetaDescription = fields.MetaDescription;
BodyContent = fields.BodyContent;
}
private PageVersion CreateDraftIfRequired(int pageId, PageVersion draft)
{
if (draft != null)
{
return(draft);
}
var command = new AddPageDraftVersionCommand();
command.PageId = pageId;
_commandExecutor.Execute(command);
return(GetDraftVersion(pageId).SingleOrDefault());
}
private async Task <PageVersion> CreateDraftIfRequiredAsync(int pageId, PageVersion draft)
{
if (draft != null)
{
return(draft);
}
var command = new AddPageDraftVersionCommand();
command.PageId = pageId;
await _commandExecutor.ExecuteAsync(command);
return(await GetDraftVersion(pageId).SingleOrDefaultAsync());
}
void ProcessDeleteCommand(string[] items)
{
for (int i = 0; i < items.Length; i++)
{
string[] keys = EcfListView.GetPrimaryKeyIdStringItems(items[i]);
if (keys != null)
{
int versionId = Int32.Parse(keys[0]);
// delete selected version
PageVersion.DeletePageVersion(versionId);
}
}
}
/// <summary>
/// Maps an EF PageVersion record from the db into an OpenGraphData
/// object.
/// </summary>
/// <param name="dbPageVersion">PageVersion record from the database.</param>
public OpenGraphData Map(PageVersion dbPageVersion)
{
var result = new OpenGraphData()
{
Description = dbPageVersion.MetaDescription,
Title = dbPageVersion.OpenGraphTitle
};
if (result.Image != null)
{
result.Image = _imageAssetSummaryMapper.Map(dbPageVersion.OpenGraphImageAsset);
}
return(result);
}
