protected override void Importing(TermPart part, ImportContentContext context)
{
// Don't do anything if the tag is not specified.
if (context.Data.Element(part.PartDefinition.Name) == null)
{
return;
}
part.Count = Int32.Parse(context.Attribute(part.PartDefinition.Name, "Count"));
part.Selectable = Boolean.Parse(context.Attribute(part.PartDefinition.Name, "Selectable"));
part.Weight = Int32.Parse(context.Attribute(part.PartDefinition.Name, "Weight"));
var identity = context.Attribute(part.PartDefinition.Name, "TaxonomyId");
var contentItem = context.GetItemFromSession(identity);
if (contentItem == null)
{
throw new OrchardException(T("Unknown taxonomy: {0}", identity));
}
part.TaxonomyId = contentItem.Id;
part.Path = "/";
foreach (var identityPath in context.Attribute(part.PartDefinition.Name, "Path").Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
var pathContentItem = context.GetItemFromSession(identityPath);
part.Path += pathContentItem.Id + "/";
}
}
protected override void Importing(TermWidgetPart part, ImportContentContext context)
{
// importing taxonomy
var taxonomyIdentity = context.Attribute(part.PartDefinition.Name, "TaxonomyId");
var taxonomy = context.GetItemFromSession(taxonomyIdentity);
if (taxonomy == null)
{
throw new OrchardException(T("Unknown taxonomy: {0}", taxonomyIdentity));
}
part.TaxonomyPartRecord = taxonomy.As <TaxonomyPart>().Record;
//importing term
var termIdentity = context.Attribute(part.PartDefinition.Name, "TermId");
var term = context.GetItemFromSession(termIdentity);
part.TermPartRecord = term.As <TermPart>().Record;
if (term == null)
{
throw new OrchardException(T("Unknown term: {0}", termIdentity));
}
// importing properties
part.FieldName = context.Attribute(part.PartDefinition.Name, "FieldName");
part.Count = Int32.Parse(context.Attribute(part.PartDefinition.Name, "Count"));
part.OrderBy = context.Attribute(part.PartDefinition.Name, "OrderBy");
}
protected override void Importing(TaxonomyNavigationPart part, ImportContentContext context)
{
part.DisplayContentCount = Boolean.Parse(context.Attribute(part.PartDefinition.Name, "DisplayContentCount"));
part.DisplayRootTerm = Boolean.Parse(context.Attribute(part.PartDefinition.Name, "DisplayRootTerm"));
part.HideEmptyTerms = Boolean.Parse(context.Attribute(part.PartDefinition.Name, "HideEmptyTerms"));
part.LevelsToDisplay = Int32.Parse(context.Attribute(part.PartDefinition.Name, "LevelsToDisplay"));
var taxonomyId = context.Attribute(part.PartDefinition.Name, "TaxonomyId");
var taxonomy = context.GetItemFromSession(taxonomyId);
if (taxonomy == null)
{
throw new OrchardException(T("Unknown taxonomy: {0}", taxonomyId));
}
part.TaxonomyId = taxonomy.Id;
var termId = context.Attribute(part.PartDefinition.Name, "TermId");
if (!String.IsNullOrEmpty(termId))
{
var term = context.GetItemFromSession(termId);
if (term == null)
{
throw new OrchardException(T("Unknown term: {0}", termId));
}
part.TermId = term.Id;
}
}
/// <summary>
///
/// </summary>
/// <param name="part"></param>
/// <param name="context"></param>
protected override void Importing(PolicyPart part, ImportContentContext context)
{
var root = context.Data.Element(part.PartDefinition.Name);
var includePendingPolicy = IncludePendingPolicyOptions.Yes;
List <string> policyTextReferencesList = new List <string>();
var policyTextReferencesIdentities = root.Attribute("PolicyTextReferencesCsv").Value;
if (policyTextReferencesIdentities != null)
{
if (policyTextReferencesIdentities.Contains("{All}"))
{
policyTextReferencesList.Add("{All}");
}
else
{
foreach (string policyTextReferencesIdentity in policyTextReferencesIdentities.Split(','))
{
var contentItem = context.GetItemFromSession(policyTextReferencesIdentity);
if (contentItem != null)
{
policyTextReferencesList.Add("{" + contentItem.Id + "}");
}
}
}
}
Enum.TryParse <IncludePendingPolicyOptions>(root.Attribute("IncludePendingPolicy").Value, out includePendingPolicy);
part.IncludePendingPolicy = includePendingPolicy;
part.PolicyTextReferencesCsv = String.Join(",", policyTextReferencesList.ToArray());
}
protected override void Importing(LocalizationPart part, ImportContentContext context)
{
// Don't do anything if the tag is not specified.
if (context.Data.Element(part.PartDefinition.Name) == null)
{
return;
}
context.ImportAttribute(part.PartDefinition.Name, "MasterContentItem", masterContentItem => {
var contentItem = context.GetItemFromSession(masterContentItem);
if (contentItem != null)
{
part.MasterContentItem = contentItem;
}
});
context.ImportAttribute(part.PartDefinition.Name, "Culture", culture => {
var targetCulture = _cultureManager.GetCultureByName(culture);
// Add Culture.
if (targetCulture == null && _cultureManager.IsValidCulture(culture))
{
_cultureManager.AddCulture(culture);
targetCulture = _cultureManager.GetCultureByName(culture);
}
part.Culture = targetCulture;
});
}
protected override void Importing(NotificationsPart part, ImportContentContext context)
{
var el = context.Data.Element(typeof(NotificationsPart).Name);
if (el == null)
{
return;
}
el.With(part)
.FromAttr(p => p.AllowNotifications);
var notificationsPlanEl = el.Element(NotificationsPlanName);
if (notificationsPlanEl != null)
{
var notificationsPlanIdentity = notificationsPlanEl.Attr("Id");
if (!string.IsNullOrEmpty(notificationsPlanIdentity))
{
var contentItem = context.GetItemFromSession(notificationsPlanIdentity);
if (contentItem != null)
{
var notificationsPlanPart = contentItem.As <NotificationsPlanPart>();
if (notificationsPlanPart != null)
{
part.NotificationsPlanPartRecord = notificationsPlanPart.Record;
}
}
}
}
}
protected override void Importing(CheckoutPolicySettingsPart part, ImportContentContext context)
{
var partName = part.PartDefinition.Name;
var root = context.Data.Element(partName);
if (root == null)
{
return;
}
var references = context.Attribute(partName, "PolicyTextReferences")
.Split(new char[] { '{', '}', ',' }, StringSplitOptions.RemoveEmptyEntries);
if (references == null || references.Length <= 1 ||
references[0].Equals("True", StringComparison.InvariantCultureIgnoreCase))
{
// by default, no policies are selected
// also true if we are importing the "None" option as selected
part.PolicyTextReferences = new string[] { CheckoutPolicySettingsPart.NoPolicyOption };
}
else if (references[1].Equals("True", StringComparison.InvariantCultureIgnoreCase))
{
// we are importing the "All" option as selected
part.PolicyTextReferences = new string[] { CheckoutPolicySettingsPart.AllPoliciesOption };
}
else
{
// parse everything else
part.PolicyTextReferences = references
.Skip(1) // "All" is false
.Select(r => $"{{{(context.GetItemFromSession(r) == null ? string.Empty : context.GetItemFromSession(r).Id.ToString())}}}")
.ToArray();
}
}
protected override void Importing(LocalizationPart part, ImportContentContext context)
{
var masterContentItem = context.Attribute(part.PartDefinition.Name, "MasterContentItem");
if (masterContentItem != null)
{
var contentItem = context.GetItemFromSession(masterContentItem);
if (contentItem != null)
{
part.MasterContentItem = contentItem;
}
}
var culture = context.Attribute(part.PartDefinition.Name, "Culture");
if (culture != null)
{
var targetCulture = _cultureManager.GetCultureByName(culture);
// Add Culture.
if (targetCulture == null && _cultureManager.IsValidCulture(culture))
{
_cultureManager.AddCulture(culture);
targetCulture = _cultureManager.GetCultureByName(culture);
}
part.Culture = targetCulture;
}
}
protected override void Imported(NavigationQueryPart part, ImportContentContext context) {
// assign the query only when everything is imported
var query = context.Attribute(part.PartDefinition.Name, "Query");
if (query != null) {
part.Record.QueryPartRecord = context.GetItemFromSession(query).As<QueryPart>().Record;
}
}
protected override void Importing(CommonPart part, ImportContentContext context)
{
// Don't do anything if the tag is not specified.
if (context.Data.Element(part.PartDefinition.Name) == null)
{
return;
}
context.ImportAttribute(part.PartDefinition.Name, "Owner", owner => {
var contentIdentity = new ContentIdentity(owner);
// use the super user if the referenced one doesn't exist;
part.Owner =
_membershipService.GetUser(contentIdentity.Get("User.UserName"))
?? _membershipService.GetUser(Services.WorkContext.CurrentSite.SuperUser);
});
context.ImportAttribute(part.PartDefinition.Name, "Container", container =>
part.Container = context.GetItemFromSession(container)
);
context.ImportAttribute(part.PartDefinition.Name, "CreatedUtc", createdUtc =>
part.CreatedUtc = XmlConvert.ToDateTime(createdUtc, XmlDateTimeSerializationMode.Utc)
);
context.ImportAttribute(part.PartDefinition.Name, "PublishedUtc", publishedUtc =>
part.PublishedUtc = XmlConvert.ToDateTime(publishedUtc, XmlDateTimeSerializationMode.Utc)
);
context.ImportAttribute(part.PartDefinition.Name, "ModifiedUtc", modifiedUtc =>
part.ModifiedUtc = XmlConvert.ToDateTime(modifiedUtc, XmlDateTimeSerializationMode.Utc)
);
}
protected override void Importing(ContentPart part, TaxonomyField field, ImportContentContext context)
{
var termIdentities = context.Attribute(field.FieldDefinition.Name + "." + field.Name, "Terms");
if (termIdentities == null)
{
return;
}
var terms = new List <ContentItem>();
foreach (var identity in termIdentities.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
var contentItem = context.GetItemFromSession(identity);
if (contentItem == null)
{
continue;
}
terms.Add(contentItem);
}
_taxonomyService.UpdateTerms(part.ContentItem, terms.Select(x => x.As <TermPart>()), field.Name);
}
protected override void Importing(ContainerWidgetPart part, ImportContentContext context)
{
var containerIdentity = context.Attribute(part.PartDefinition.Name, "Container");
if (containerIdentity != null)
{
var container = context.GetItemFromSession(containerIdentity);
if (container != null)
{
part.Record.ContainerId = container.Id;
}
}
var pageSize = context.Attribute(part.PartDefinition.Name, "PageSize");
if (pageSize != null)
{
part.Record.PageSize = Convert.ToInt32(pageSize);
}
var filterByValue = context.Attribute(part.PartDefinition.Name, "FilterByValue");
if (filterByValue != null)
{
part.Record.FilterByValue = filterByValue;
}
}
protected override void Importing(TerritoryPart part, ImportContentContext context)
{
// Set stuff in the record based off what is being imported
if (context.Data.Element(part.PartDefinition.Name) == null)
{
return;
}
var hierarchyIdentity = context.Attribute(part.PartDefinition.Name, "HierarchyId");
if (hierarchyIdentity == null)
{
part.Record.Hierarchy = null;
}
else
{
var ci = context.GetItemFromSession(hierarchyIdentity);
var hierarchy = ci.As <TerritoryHierarchyPart>();
_territoriesHierarchyService.AddTerritory(part, hierarchy);
}
var parentIdentity = context.Attribute(part.PartDefinition.Name, "ParentTerritoryId");
if (parentIdentity == null)
{
part.Record.ParentTerritory = null;
}
else
{
var ci = context.GetItemFromSession(parentIdentity.ToString());
var parent = ci.As <TerritoryPart>();
_territoriesHierarchyService.AssignParent(part, parent);
}
var internalIdentity = context.Attribute(part.PartDefinition.Name, "TerritoryInternalRecordId");
if (internalIdentity == null)
{
part.Record.TerritoryInternalRecord = null;
}
else
{
_territoriesHierarchyService.AssignInternalRecord(part, internalIdentity.ToString());
}
}
protected override void Importing(BlogArchivesPart part, ImportContentContext context)
{
var blog = context.Attribute(part.PartDefinition.Name, "Blog");
if (blog != null)
{
part.BlogId = context.GetItemFromSession(blog).Id;
}
}
protected override void Importing(CustomTemplatePickerPart part, ImportContentContext context)
{
context.ImportAttribute(part.PartDefinition.Name, "SelectedTemplate", x => {
var itemFromid = context.GetItemFromSession(x);
if (itemFromid != null && itemFromid.Is <TemplatePart>())
{
part.SelectedTemplate = itemFromid.As <TemplatePart>();
}
});
}
protected override void Imported(BingLocationPart part, ImportContentContext context)
{
// assign the bingMapList only when everything is imported
var bingMapList = context.Attribute(part.PartDefinition.Name, "BingMapList");
if (bingMapList != null)
{
part.Record.BingMapList = context.GetItemFromSession(bingMapList).As <BingMapListPart>().ContentItem.Record;
}
}
private static int?GetTemplateId(ImportContentContext context, string templateIdentity)
{
if (String.IsNullOrWhiteSpace(templateIdentity))
{
return(null);
}
var template = context.GetItemFromSession(templateIdentity);
return(template != null ? template.Id : default(int?));
}
protected override void Importing(BlogArchivesPart part, ImportContentContext context)
{
// Don't do anything if the tag is not specified.
if (context.Data.Element(part.PartDefinition.Name) == null)
{
return;
}
context.ImportAttribute(part.PartDefinition.Name, "Blog", blog =>
part.BlogId = context.GetItemFromSession(blog).Id
);
}
protected override void Importing(CommunicationAdvertisingPart part, ImportContentContext context)
{
context.ImportAttribute(part.PartDefinition.Name, "CampaignId", x => {
// cerca la campagna con l'identity indicato
var campPartFromid = context.GetItemFromSession(x);
// verifica che si tratti effettivamente di una campagna
if (campPartFromid != null && campPartFromid.Has <CommunicationCampaignPart>())
{
part.CampaignId = campPartFromid.Id;
}
});
}
protected override void Importing(CaseArchivesPart part, ImportContentContext context)
{
// Don't do anything if the tag is not specified.
if (context.Data.Element(part.PartDefinition.Name) == null)
{
return;
}
context.ImportAttribute(part.PartDefinition.Name, "Case", cAse =>
part.CaseNumber = context.GetItemFromSession(cAse).Id
);
}
public void Import(dynamic state, ImportContentContext context)
{
string queryIdentity = Convert.ToString(state.QueryId);
if (!string.IsNullOrWhiteSpace(queryIdentity))
{
var query = context.GetItemFromSession(queryIdentity);
if (query != null)
{
state.QueryId = query.Id.ToString();
}
}
}
protected override void Importing(BundlePart part, ImportContentContext context)
{
var productQuantities =
context.Data.Element("BundlePart").Elements("Product")
.Select(e => new ProductQuantity {
ProductId = context.GetItemFromSession(e.Attribute("id").Value).Id,
Quantity = int.Parse(e.Attribute("quantity").Value, CultureInfo.InvariantCulture)
});
foreach (var productQuantity in productQuantities)
{
_bundleService.AddProduct(productQuantity.Quantity, productQuantity.ProductId, part.Record);
}
}
protected override void Importing(BlogPostMenuItemPart part, ImportContentContext context)
{
var contentItemId = context.Attribute(part.PartDefinition.Name, "ContentItem");
if (contentItemId != null)
{
var contentItem = context.GetItemFromSession(contentItemId);
part.Content = contentItem;
}
else
{
part.Content = null;
}
}
protected override void Imported(ProjectionPart part, ImportContentContext context)
{
// assign the query only when everythin is imported
var query = context.Attribute(part.PartDefinition.Name, "Query");
if (query != null)
{
part.Record.QueryPartRecord = context.GetItemFromSession(query).As <QueryPart>().Record;
var layoutIndex = context.Attribute(part.PartDefinition.Name, "LayoutIndex");
if (layoutIndex != null && Int32.Parse(layoutIndex) != -1)
{
part.Record.LayoutRecord = part.Record.QueryPartRecord.Layouts[Int32.Parse(layoutIndex)];
}
}
}
protected override void Importing(MessageTemplatePart part, ImportContentContext context)
{
context.ImportAttribute(part.PartDefinition.Name, "Title", x => part.Title = x);
context.ImportAttribute(part.PartDefinition.Name, "Subject", x => part.Subject = x);
context.ImportAttribute(part.PartDefinition.Name, "Text", x => part.Text = x);
context.ImportAttribute(part.PartDefinition.Name, "IsLayout", x => part.IsLayout = XmlConvert.ToBoolean(x));
context.ImportAttribute(part.PartDefinition.Name, "Layout", x => {
var layout = context.GetItemFromSession(x);
if (layout != null && layout.Is <MessageTemplatePart>())
{
part.Layout = layout.As <MessageTemplatePart>();
}
});
}
protected override void Imported(TaxonomyMenuPart part, ImportContentContext context)
{
var taxonomyId = GetAttribute <string>(context, part.PartDefinition.Name, "TaxonomyPartRecordId");
if (!string.IsNullOrWhiteSpace(taxonomyId))
{
var taxonomy = context.GetItemFromSession(taxonomyId);
if (taxonomy != null)
{
part.TaxonomyPartRecord = taxonomy.As <TaxonomyPart>().Record;
}
}
var termId = GetAttribute <string>(context, part.PartDefinition.Name, "TermPartRecordId");
if (!string.IsNullOrWhiteSpace(termId))
{
var term = context.GetItemFromSession(termId);
if (term != null)
{
part.TermPartRecord = term.As <TermPart>().Record;
}
}
}
protected override void Importing(OptionItemPart part, ImportContentContext context)
{
part.Record.Selectable = Boolean.Parse(context.Attribute(part.PartDefinition.Name, "Selectable"));
part.Record.Weight = Int32.Parse(context.Attribute(part.PartDefinition.Name, "Weight"));
var identity = context.Attribute(part.PartDefinition.Name, "OptionSetId");
var contentItem = context.GetItemFromSession(identity);
if (contentItem == null)
{
throw new OrchardException(T("Unknown taxonomy: {0}", identity));
}
part.Record.OptionSetId = contentItem.Id;
}
protected override void Importing(RecentBlogPostsPart part, ImportContentContext context)
{
// Don't do anything if the tag is not specified.
if (context.Data.Element(part.PartDefinition.Name) == null)
{
return;
}
context.ImportAttribute(part.PartDefinition.Name, "Blog", blog =>
part.BlogId = context.GetItemFromSession(blog).Id
);
context.ImportAttribute(part.PartDefinition.Name, "Count", count =>
part.Count = Convert.ToInt32(count)
);
}
protected override void Importing(ContentMenuItemPart part, ImportContentContext context)
{
// Don't do anything if the tag is not specified.
if (context.Data.Element(part.PartDefinition.Name) == null)
{
return;
}
context.ImportAttribute(part.PartDefinition.Name, "ContentItem",
contentItemId => {
var contentItem = context.GetItemFromSession(contentItemId);
part.Content = contentItem;
}, () =>
part.Content = null
);
}
protected override void Importing(RecentBlogPostsPart part, ImportContentContext context)
{
var blog = context.Attribute(part.PartDefinition.Name, "Blog");
if (blog != null)
{
part.BlogId = context.GetItemFromSession(blog).Id;
}
var count = context.Attribute(part.PartDefinition.Name, "Count");
if (count != null)
{
part.Count = Convert.ToInt32(count);
}
}