public void RestoreDoesNotUnpublishPreviousLatestVersion()
{
// Generate some versions
var gamma1 = _manager.Create(DefaultGammaName, VersionOptions.Published);
Flush();
var gamma2 = _manager.GetDraftRequired(gamma1.Id);
_manager.Publish(gamma2);
Flush();
var gamma3 = _manager.GetDraftRequired(gamma1.Id);
_manager.Publish(gamma3);
Flush();
// Restore to version 1.
var gamma4 = _manager.Restore(gamma1, VersionOptions.Number(1));
FlushAndClear();
// Assert that version 3 is still published.
var gamma = _manager.Get(gamma1.Id, VersionOptions.Number(3));
Assert.That(gamma.VersionRecord.Published, Is.True);
}
// /Contents/Item/Preview/72
// /Contents/Item/Preview/72?version=5
public ActionResult Preview(int?id, int?version)
{
if (id == null)
{
return(HttpNotFound());
}
var versionOptions = VersionOptions.Latest;
if (version != null)
{
versionOptions = VersionOptions.Number((int)version);
}
var contentItem = _contentManager.Get(id.Value, versionOptions);
if (contentItem == null)
{
return(HttpNotFound());
}
if (!Services.Authorizer.Authorize(Permissions.PreviewContent, contentItem, T("Cannot preview content")))
{
return(new HttpUnauthorizedResult());
}
var model = _contentManager.BuildDisplay(contentItem);
if (_hca.Current().Request.IsAjaxRequest())
{
return(new ShapePartialResult(this, model));
}
return(View(model));
}
public void RestoreWithPublishUnpublishesPreviousLatestVersion()
{
// Generate some versions
var gamma1 = _manager.Create(DefaultGammaName, VersionOptions.Published);
Flush();
var gamma2 = _manager.GetDraftRequired(gamma1.Id);
_manager.Publish(gamma2);
Flush();
var gamma3 = _manager.GetDraftRequired(gamma1.Id);
_manager.Publish(gamma3);
Flush();
// Restore to version 1.
var gamma4 = _manager.Restore(gamma1, VersionOptions.Restore(1, publish: true));
FlushAndClear();
// Assert that version 3 is no longer published and that version 4 is now published.
var gamma = _manager.Get(gamma1.Id, VersionOptions.Number(3));
Assert.That(gamma.VersionRecord.Published, Is.False);
Assert.That(gamma4.VersionRecord.Published, Is.True);
}
public ActionResult CompareVersion(int id, int versionId)
{
var latest = _contentManager.Get(id, VersionOptions.Latest);
var compare = _contentManager.Get(id, VersionOptions.Number(versionId));
if (latest == null || compare == null)
{
return(HttpNotFound());
}
if (!_authorizer.Authorize(Orchard.Core.Contents.Permissions.ViewContent, latest))
{
return(new HttpUnauthorizedResult());
}
var viewModel = new CompareVersionViewModel()
{
Latest = _contentManager.BuildEditor(latest),
Compare = _contentManager.BuildEditor(compare),
LatestVersion = latest.Version,
CompareVersion = compare.Version,
ContentType = latest.ContentType,
Title = latest.Has <TitlePart>() ? latest.As <TitlePart>().Title : ""
};
return(View(viewModel));
}
// /Contents/Item/Preview/72
// /Contents/Item/Preview/72?version=5
public ActionResult Preview(int id, int?version)
{
var versionOptions = VersionOptions.Latest;
if (version != null)
{
versionOptions = VersionOptions.Number((int)version);
}
var contentItem = _contentManager.Get(id, versionOptions);
if (contentItem == null)
{
return(HttpNotFound());
}
if (!Services.Authorizer.Authorize(Permissions.ViewContent, contentItem, T("Cannot preview content")))
{
return(new HttpUnauthorizedResult());
}
if (!Services.Authorizer.Authorize(Permissions.EditContent, contentItem, T("Cannot preview content")))
{
return(new HttpUnauthorizedResult());
}
dynamic model = _contentManager.BuildDisplay(contentItem);
return(new ShapeResult(this, model));
}
public void ImportingDraftShouldCreateNewDraftForExistingPublished()
{
// Create a draft and an export of it.
var contentItem = _contentManager.New(ContentTypeName);
contentItem.As <TitlePart>().Title = "Draft Dummy";
_contentManager.Create(contentItem, VersionOptions.Draft);
var element = _contentManager.Export(contentItem);
// Change the title and publish the draft.
contentItem.As <TitlePart>().Title = "Published Dummy";
_contentManager.Publish(contentItem);
// Import the element representing the draft.
Import(element);
// Assert that version one is still the published one but no more the latest.
var published = _contentManager.Get(contentItem.Id, VersionOptions.Number(1));
Assert.That(published.VersionRecord.Published, Is.True);
Assert.That(published.VersionRecord.Latest, Is.False);
Assert.That(published.As <TitlePart>().Title, Is.EqualTo("Published Dummy"));
// Assert that a new draft was created for the published item.
var latest = _contentManager.Get(contentItem.Id, VersionOptions.Number(2));
Assert.That(latest.VersionRecord.Published, Is.False);
Assert.That(latest.VersionRecord.Latest, Is.True);
Assert.That(latest.As <TitlePart>().Title, Is.EqualTo("Draft Dummy"));
}
public void ImportingPublishedShouldUpdateAndPublishExistingPublishedItem()
{
// Create a published item and an export of it.
var contentItem = _contentManager.New(ContentTypeName);
contentItem.As <TitlePart>().Title = "Published Dummy";
_contentManager.Create(contentItem, VersionOptions.Published);
var element = _contentManager.Export(contentItem);
// Change the title and publish the item.
element.Element("TitlePart").Attr("Title", "Published Smarty");
// Import the element representing the updated published version.
Import(element);
// Assert that an additional version was created.
var allVersions = _contentManager.GetAllVersions(contentItem.Id).ToList();
Assert.That(allVersions.Count, Is.EqualTo(2));
// Assert that no additional item was created.
var allItems = _contentManager.Query(VersionOptions.Latest).List().ToList();
Assert.That(allItems.Count, Is.EqualTo(1));
// Assert that the item has been updated and published.
var published = _contentManager.Get(contentItem.Id, VersionOptions.Number(2));
Assert.That(published.VersionRecord.Published, Is.True);
Assert.That(published.VersionRecord.Latest, Is.True);
Assert.That(published.As <TitlePart>().Title, Is.EqualTo("Published Smarty"));
}
public ActionResult PromoteVersion(int id, int versionId)
{
var versionToPromote = _contentManager.Get(id, VersionOptions.Number(versionId));
if (versionToPromote == null)
{
return(HttpNotFound());
}
if (!_authorizer.Authorize(Orchard.Core.Contents.Permissions.EditContent, versionToPromote))
{
return(new HttpUnauthorizedResult());
}
var newVersionNumber = _versionManager.BuildNewContentItemVersion(versionToPromote);
if (newVersionNumber == 0)
{
_notifier.Error(T("Version {0} of this content CANNOT be promoted to latest, as this content is in a Read Only state", versionId));
}
else
{
_notifier.Information(T("Version {0} of this content has been promoted to latest (draft) as version {1}", versionId, newVersionNumber));
}
return(RedirectToAction("Edit", "Admin", new { area = "", id = id }));
}
public async Task <IActionResult> Preview(string contentItemId, int?version)
{
if (contentItemId == null)
{
return(NotFound());
}
var versionOptions = VersionOptions.Latest;
if (version != null)
{
versionOptions = VersionOptions.Number((int)version);
}
var contentItem = await _contentManager.GetAsync(contentItemId, versionOptions);
if (contentItem == null)
{
return(NotFound());
}
if (!await _authorizationService.AuthorizeAsync(User, Permissions.PreviewContent, contentItem))
{
return(Unauthorized());
}
var model = await _contentItemDisplayManager.BuildDisplayAsync(contentItem, this);
return(View(model));
}
public IHttpActionResult Preview(int id, int version, string displayType = "Detail")
{
var versionOptions = VersionOptions.Number((int)version);
var contentItem = _contentManager.Get(id, versionOptions);
if (contentItem == null)
{
return(NotFound());
}
if (!Services.Authorizer.Authorize(Permissions.PreviewContent, contentItem, T("Cannot preview content")))
{
return(Unauthorized());
}
dynamic model;
using (_alterations.CreateScope("Translate")) {
model = _contentManager.BuildDisplay(contentItem, displayType);
}
var vm = _serializer.Display(model);
return(Ok(vm));
}
public void RestoreUnsetsPreviousLatestVersion()
{
// Generate some versions
var gamma1 = _manager.Create(DefaultGammaName, VersionOptions.Published);
Flush();
var gamma2 = _manager.GetDraftRequired(gamma1.Id);
_manager.Publish(gamma2);
Flush();
var gamma3 = _manager.GetDraftRequired(gamma1.Id);
_manager.Publish(gamma3);
Flush();
// Restore to version 1.
var gamma4 = _manager.Restore(gamma1, VersionOptions.Number(1));
FlushAndClear();
// Assert that version 3 is no longer the latest version.
var gamma = _manager.Get(gamma1.Id, VersionOptions.Number(3));
Assert.That(gamma.VersionRecord.Latest, Is.False);
}
public void RestoreCreatesNewVersionBasedOnLatestVersion()
{
// Generate some versions
var gamma1 = _manager.Create(DefaultGammaName, VersionOptions.Published);
Flush();
var gamma2 = _manager.GetDraftRequired(gamma1.Id);
_manager.Publish(gamma2);
Flush();
var gamma3 = _manager.GetDraftRequired(gamma1.Id);
_manager.Publish(gamma3);
Flush();
// Restore to version 1.
var gamma4 = _manager.Restore(gamma1, VersionOptions.Number(1));
FlushAndClear();
// Assert that a new version was created and that it is the latest.
var gamma = _manager.Get(gamma1.Id, VersionOptions.Number(4));
Assert.That(gamma.Version, Is.EqualTo(4));
Assert.That(gamma.VersionRecord.Latest, Is.True);
}
public void InitialVersionCanBeSpecifiedAndIsPublished()
{
var gamma1 = _manager.Create <GammaPart>(DefaultGammaName, VersionOptions.Number(4));
Assert.That(gamma1.ContentItem.Version, Is.EqualTo(4));
Assert.That(gamma1.ContentItem.VersionRecord.Published, Is.True);
_session.Flush();
_session.Clear();
}
public bool Promote(int id, int versionId)
{
//Get the last version number to create a new version
int lastversionNumber = _contentManager.GetAllVersions(id).Max(r => r.VersionRecord.Number);
//Retrieve the content item to clone
ContentItem contentItem = _contentManager.Get(id, VersionOptions.VersionRecord(versionId));
if (contentItem == null)
{
_notifier.Error(T("Could not find content with id {0}", id));
return(false);
}
int versionOfContentItemToClone = contentItem.VersionRecord.Number;
//Unfortunately it creates not a new record but updates the old record
_contentManager.Create(contentItem, VersionOptions.Number(lastversionNumber + 1));
//var newContent = BuildNewVersion(contentItem);
//Update the table that a new version is added
ContentItemVersionRecord previousLastRecord =
_versionManagerDataService.ContentItemVersionRecords.FirstOrDefault(
r => r.ContentItemRecord.Id == id && r.Latest);
ContentItemVersionRecord newLastRecord =
_versionManagerDataService.ContentItemVersionRecords.Where(r => r.ContentItemRecord.Id == contentItem.Id)
.OrderByDescending(r => r.Number)
.FirstOrDefault();
if (previousLastRecord != null && newLastRecord != null)
{
previousLastRecord.Latest = false;
newLastRecord.Latest = true;
_versionManagerDataService.SetContentItemVersionRecord(previousLastRecord);
_versionManagerDataService.SetContentItemVersionRecord(newLastRecord);
}
_notifier.Information(T("Successfully promoted version {0} to {1}.", versionOfContentItemToClone,
lastversionNumber + 1));
return(true);
}
public ActionResult ViewVersion(int id, int versionId)
{
var contentItem = _contentManager.Get(id, VersionOptions.Number(versionId));
if (contentItem == null)
{
return(HttpNotFound());
}
if (!_authorizer.Authorize(Orchard.Core.Contents.Permissions.ViewContent, contentItem))
{
return(new HttpUnauthorizedResult());
}
var model = _contentManager.BuildEditor(contentItem);
return(View(model));
}
public ActionResult Restore(int id, int version, string returnUrl)
{
var contentItem = _contentManager.Get(id, VersionOptions.Number(version));
if (!_authorizer.Authorize(Core.Contents.Permissions.PublishContent, contentItem))
{
return(new HttpUnauthorizedResult());
}
var contentType = _contentDefinitionManager.GetTypeDefinition(contentItem.ContentType);
var draftable = contentType.Settings.GetModel <ContentTypeSettings>().Draftable;
var restoredContentItem = _contentManager.Restore(contentItem, VersionOptions.Restore(version, publish: !draftable));
var restoredContentItemTitle = _contentManager.GetItemMetadata(restoredContentItem).DisplayText;
_notifier.Information(T(""{0}" has been restored.", restoredContentItemTitle));
return(this.RedirectReturn(returnUrl, () => Url.Action("Index", "Admin")));
}
public ActionResult Detail(int id, int version)
{
var contentItem = _contentManager.Get(id, VersionOptions.Number(version));
if (!_authorizer.Authorize(Core.Contents.Permissions.ViewContent, contentItem))
{
return(new HttpUnauthorizedResult());
}
var auditTrailPart = contentItem.As <AuditTrailPart>();
if (auditTrailPart != null)
{
auditTrailPart.ShowComment = true;
}
var editor = _contentManager.BuildEditor(contentItem);
return(View(editor));
}
private ContentItem GetRoutedContentItem(HttpRequestBase request)
{
String area = GetRouteValue("area", request);
String action = GetRouteValue("action", request);
int contentId;
if (!String.Equals(area, "Containers", StringComparison.OrdinalIgnoreCase) && !String.Equals(area, "Contents", StringComparison.OrdinalIgnoreCase))
{
return(null);
}
if (!String.Equals(GetRouteValue("controller", request), "Item", StringComparison.OrdinalIgnoreCase))
{
return(null);
}
if (!int.TryParse(GetRouteValue("id", request), out contentId))
{
return(null);
}
if (String.Equals(action, "Display", StringComparison.OrdinalIgnoreCase))
{
return(_contentManager.Get(contentId, VersionOptions.Published));
}
else if (String.Equals(action, "Preview", StringComparison.OrdinalIgnoreCase))
{
VersionOptions versionOptions = VersionOptions.Latest;
int version;
if (int.TryParse(request.QueryString["version"], out version))
{
versionOptions = VersionOptions.Number(version);
}
return(_contentManager.Get(contentId, versionOptions));
}
else
{
return(null);
}
}
public ActionResult Details(int id, int?version)
{
var model = new ContentDetailsViewModel {
Item = version == null?_contentManager.Get(id) : _contentManager.Get(id, VersionOptions.Number((int)version))
};
model.PartTypes = model.Item.ContentItem.Parts
.Select(x => x.GetType())
.SelectMany(x => AllTypes(x))
.Distinct();
model.DisplayShape = _contentManager.BuildDisplay(model.Item, "Detail");
model.EditorShape = _contentManager.BuildEditor(model.Item);
return(View(model));
}