| public Get ( string id ) : Orchard.ContentManagement.ContentItem | ||
| id | string | |
| return | Orchard.ContentManagement.ContentItem | |
// <Data />
// Import Data
public void ExecuteRecipeStep(RecipeContext recipeContext) {
if (!String.Equals(recipeContext.RecipeStep.Name, "Data", StringComparison.OrdinalIgnoreCase)) {
return;
}
// First pass to resolve content items from content identities for all content items, new and old.
var importContentSession = new ImportContentSession(_orchardServices.ContentManager);
foreach (var element in recipeContext.RecipeStep.Step.Elements()) {
var elementId = element.Attribute("Id");
if (elementId == null)
continue;
var identity = elementId.Value;
var status = element.Attribute("Status");
importContentSession.Set(identity, element.Name.LocalName);
var item = importContentSession.Get(identity);
}
// Second pass to import the content items.
foreach (var element in recipeContext.RecipeStep.Step.Elements()) {
_orchardServices.ContentManager.Import(element, importContentSession);
}
recipeContext.Executed = true;
}
public virtual ContentItem Clone(ContentItem contentItem)
{
// Mostly taken from: http://orchard.codeplex.com/discussions/396664
var importContentSession = new ImportContentSession(this);
var element = Export(contentItem);
// If a handler prevents this element from being exported, it can't be cloned
if (element == null)
{
throw new InvalidOperationException("The content item couldn't be cloned because a handler prevented it from being exported.");
}
var elementId = element.Attribute("Id");
var copyId = elementId.Value + "-copy";
elementId.SetValue(copyId);
var status = element.Attribute("Status");
if (status != null)
{
status.SetValue("Draft"); // So the copy is always a draft.
}
importContentSession.Set(copyId, element.Name.LocalName);
Import(element, importContentSession);
return(importContentSession.Get(copyId, element.Name.LocalName));
}
private bool LocalIdentifierExists(ImportSyncAction identifier, ImportContentSession importContentSession)
{
var newIdentifier = identifier.Step.Step.Attribute("Id");
if (newIdentifier == null)
return false;
var contentItem = importContentSession.Get(newIdentifier.Value);
if (contentItem == null)
return false;
return true;
}
public void CompleteImport(XElement element, ImportContentSession importContentSession) {
var elementId = element.Attribute("Id");
if (elementId == null) {
return;
}
var identity = elementId.Value;
if (String.IsNullOrWhiteSpace(identity)) {
return;
}
var item = importContentSession.Get(identity, VersionOptions.Latest, XmlConvert.DecodeName(element.Name.LocalName));
var context = new ImportContentContext(item, element, importContentSession);
Handlers.Invoke(contentHandler => contentHandler.ImportCompleted(context), Logger);
}
// Insert or Update imported data into the content manager.
// Call content item handlers.
public void Import(XElement element, ImportContentSession importContentSession)
{
var elementId = element.Attribute("Id");
if (elementId == null)
{
return;
}
var identity = elementId.Value;
if (String.IsNullOrWhiteSpace(identity))
{
return;
}
var status = element.Attribute("Status");
var item = importContentSession.Get(identity, VersionOptions.Latest, XmlConvert.DecodeName(element.Name.LocalName));
if (item == null)
{
item = New(XmlConvert.DecodeName(element.Name.LocalName));
if (status != null && status.Value == "Draft")
{
Create(item, VersionOptions.Draft);
}
else
{
Create(item);
}
}
// create a version record if import handlers need it
if (item.VersionRecord == null)
{
item.VersionRecord = new ContentItemVersionRecord {
ContentItemRecord = new ContentItemRecord {
ContentType = AcquireContentTypeRecord(item.ContentType)
},
Number = 1,
Latest = true,
Published = true
};
}
var context = new ImportContentContext(item, element, importContentSession);
foreach (var contentHandler in Handlers)
{
contentHandler.Importing(context);
}
foreach (var contentHandler in Handlers)
{
contentHandler.Imported(context);
}
var savedItem = Get(item.Id, VersionOptions.Latest);
// the item has been pre-created in the first pass of the import, create it in db
if (savedItem == null)
{
if (status != null && status.Value == "Draft")
{
Create(item, VersionOptions.Draft);
}
else
{
Create(item);
}
}
if (status == null || status.Value == Published)
{
Publish(item);
}
}
public ActionResult Export(string[] sync, string direction)
{
if (sync == null)
{
return RedirectToAction("Different");
}
var settings = _contentSyncSettingsRepository.Table.SingleOrDefault();
if (settings == null
|| string.IsNullOrWhiteSpace(settings.RemoteUrl))
{
_services.Notifier.Add(NotifyType.Warning,
new LocalizedString("You need to set a remote Orchard instance url"));
return RedirectToAction("Settings");
}
string remote = settings.RemoteUrl;
StringBuilder result = new StringBuilder();
ImportContentSession importContentSession = new ImportContentSession(_contentManager);
XDocument synchronisation = new XDocument();
synchronisation.Add(new XElement("ContentSync"));
foreach (var action in sync)
{
XElement syncXml = new XElement("Sync");
var contentItem = importContentSession.Get(action);
if (contentItem == null)
{
// todo: log
continue;
}
syncXml.Add(new XAttribute("Action", "Import"));
syncXml.Add(_contentManager.Export(contentItem));
synchronisation.Element("ContentSync").Add(syncXml);
}
Logger.Debug(synchronisation.ToString());
// send to other server
string remoteImportEndpoint = remote + "/Admin/ContentImportExport/Import";
HttpWebRequest post = HttpWebRequest.Create(remoteImportEndpoint) as HttpWebRequest;
post.Method = "POST";
using (var requestStream = post.GetRequestStream())
using (var requestWriter = new StreamWriter(requestStream, Encoding.UTF8))
{
requestWriter.Write(synchronisation.ToString());
requestWriter.Flush();
}
try
{
using (var response = post.GetResponse() as HttpWebResponse)
{
if (response.StatusCode == HttpStatusCode.Accepted)
{
_services.Notifier.Add(NotifyType.Information,
new LocalizedString("The content was published successfully"));
_signals.Trigger(SynchronisationMapFactory.MapInvalidationTrigger);
}
else
{
_services.Notifier.Add(NotifyType.Error,
new LocalizedString("A problem occurred: " + response.StatusDescription));
}
}
}
catch (Exception ex)
{
_services.Notifier.Add(NotifyType.Error,
new LocalizedString("A problem occurred: " + ex.Message));
}
return RedirectToAction("Different");
}
public void GetNextInBatchInitialisedTwoBatchesReturnsItemsOnceEach() {
var session = new ImportContentSession(_contentManager.Object);
session.Set(_testItemIdentity1.ToString(), "TestContentType");
session.Set(_testItemIdentity2.ToString(), "TestContentType");
session.Set(_testItemIdentity3.ToString(), "TestContentType");
session.Set(_testItemIdentity4.ToString(), "TestContentType");
session.Set(_testItemIdentity5.ToString(), "TestContentType");
session.InitializeBatch(0, 2);
var firstIdentity = session.GetNextInBatch();
//get later item as dependency
var dependencyItem = session.Get(_testItemIdentity5.ToString(), VersionOptions.Latest);
var dependencyIdentity = session.GetNextInBatch();
var secondIdentity = session.GetNextInBatch();
var afterBatch1 = session.GetNextInBatch();
session.InitializeBatch(2, 2);
var thirdIdentity = session.GetNextInBatch();
var fourthdentity = session.GetNextInBatch();
var afterBatch2 = session.GetNextInBatch();
session.InitializeBatch(4, 2);
var fifthIdentity = session.GetNextInBatch();
var afterBatch3 = session.GetNextInBatch();
var comparer = new ContentIdentity.ContentIdentityEqualityComparer();
Assert.That(comparer.Equals(_testItemIdentity1, firstIdentity));
Assert.That(comparer.Equals(_testItemIdentity5, dependencyIdentity));
Assert.That(comparer.Equals(_testItemIdentity2, secondIdentity));
Assert.That(afterBatch1, Is.Null);
Assert.That(comparer.Equals(_testItemIdentity3, thirdIdentity));
Assert.That(comparer.Equals(_testItemIdentity4, fourthdentity));
Assert.That(afterBatch2, Is.Null);
Assert.That(fifthIdentity, Is.Null); //already processed as dependency
Assert.That(afterBatch3, Is.Null);
}
public void GetItemExistsAndDraftRequiredVersionOptionReturnsDraft() {
var session = new ImportContentSession(_contentManager.Object);
session.Set(_testItemIdentity1.ToString(), "TestContentType");
var sessionItem = session.Get(_testItemIdentity1.ToString(), VersionOptions.DraftRequired);
Assert.IsNotNull(sessionItem);
Assert.That(1, Is.EqualTo(sessionItem.Id));
Assert.IsFalse(sessionItem.IsPublished());
}
public void GetItemExistsAndLatestVersionOptionReturnsPublishedItem() {
var session = new ImportContentSession(_contentManager.Object);
session.Set(_testItemIdentity1.ToString(), "TestContentType");
var sessionItem = session.Get(_testItemIdentity1.ToString());
Assert.IsNotNull(sessionItem);
Assert.AreEqual(1, sessionItem.Id);
Assert.IsTrue(sessionItem.IsPublished());
}
private void Replace(ImportSyncAction action, ImportContentSession session)
{
// update the identifier on the item in the local instance
// then let the import continue so the existing item gets paved over
if (action.Action == "Replace" && !string.IsNullOrWhiteSpace(action.TargetId))
{
var item = session.Get(action.TargetId);
if (item == null)
{
return;
}
var newIdentifier = action.Step.Step.Attribute("Id");
if (newIdentifier == null)
return;
var newIdentity = new ContentIdentity(newIdentifier.Value);
var existingIdentity = new ContentIdentity(action.TargetId);
if (!newIdentity.Equals(existingIdentity))
{
Logger.Debug("import - items {0} and {1} have different identifiers", existingIdentity.Get("Identifier"), newIdentity.Get("Identifier"));
item.As<IdentityPart>().Identifier = newIdentity.Get("Identifier");
session.Store(newIdentity.Get("Identifier"), item);
}
}
}
