/// <summary>
/// Shortcut to get an @All Entity Describing an Attribute
/// </summary>
private static ImportEntity GetAttributeMetaData(string name, string notes, bool? visibleInEditUi, string defaultValue = null)
{
var allEntity = new ImportEntity
{
AttributeSetStaticName = "@All",
Values = new Dictionary<string, List<IValueImportModel>>()
};
if (!string.IsNullOrEmpty(name))
allEntity.Values.Add("Name", new List<IValueImportModel> { new ValueImportModel<string>(allEntity) { Value = name } });
if (!string.IsNullOrEmpty(notes))
allEntity.Values.Add("Notes", new List<IValueImportModel> { new ValueImportModel<string>(allEntity) { Value = notes } });
if (visibleInEditUi.HasValue)
allEntity.Values.Add("VisibleInEditUI", new List<IValueImportModel> { new ValueImportModel<bool?>(allEntity) { Value = visibleInEditUi } });
if (defaultValue != null)
allEntity.Values.Add("DefaultValue", new List<IValueImportModel> { new ValueImportModel<string>(allEntity) { Value = defaultValue } });
return allEntity;
}
/// <summary>
/// Returns an EAV import entity
/// </summary>
/// <param name="xEntity">xEntity to parse</param>
/// <param name="assignmentObjectTypeId">assignmentObjectTypeId of the Entity</param>
/// <param name="targetDimensions">all Dimensions that exist in the Target-App/Zone</param>
/// <param name="sourceDimensions">all Dimensions that exist in the Source-App/Zone</param>
/// <param name="sourceDefaultDimensionId">Default Dimension ID of the Surce-App/Zone</param>
/// <param name="defaultLanguage">Default Language of the Target-App/Zone</param>
/// <param name="keyNumber">KeyNumber of the Entity</param>
/// <param name="keyGuid">KeyGuid of the Entity</param>
/// <param name="keyString">KeyString of the Entity</param>
public static ImportEntity GetImportEntity(XElement xEntity, int assignmentObjectTypeId, List<Dimension> targetDimensions, List<Dimension> sourceDimensions, int? sourceDefaultDimensionId, string defaultLanguage, int? keyNumber = null, Guid? keyGuid = null, string keyString = null)
{
var targetEntity = new ImportEntity
{
AssignmentObjectTypeId = assignmentObjectTypeId,
AttributeSetStaticName = xEntity.Attribute("AttributeSetStaticName").Value,
EntityGuid = Guid.Parse(xEntity.Attribute("EntityGUID").Value),
KeyNumber = keyNumber,
KeyGuid = keyGuid,
KeyString = keyString
};
var targetValues = new Dictionary<string, List<IValueImportModel>>();
// Group values by StaticName
var valuesGroupedByStaticName = xEntity.Elements("Value")
.GroupBy(v => v.Attribute("Key").Value, e => e, (key, e) => new { StaticName = key, Values = e.ToList() });
// Process each attribute (values grouped by StaticName)
foreach (var sourceAttribute in valuesGroupedByStaticName)
{
var sourceValues = sourceAttribute.Values;
var tempTargetValues = new List<ImportValue>();
// Process each target's language
foreach (var targetDimension in targetDimensions.OrderByDescending(p => p.ExternalKey == defaultLanguage).ThenBy(p => p.ExternalKey))
{
// This list will contain all source dimensions
var sourceLanguages = new List<Dimension>();
// Add exact match source language, if exists
var exactMatchSourceDimension = sourceDimensions.FirstOrDefault(p => p.ExternalKey == targetDimension.ExternalKey);
if (exactMatchSourceDimension != null)
sourceLanguages.Add(exactMatchSourceDimension);
// Add un-exact match language
var unExactMatchSourceDimensions = sourceDimensions.Where(p => p.ExternalKey != targetDimension.ExternalKey && p.ExternalKey.StartsWith(targetDimension.ExternalKey.Substring(0, 3)))
.OrderByDescending(p => p.ExternalKey == defaultLanguage)
.ThenByDescending(p => p.ExternalKey.Substring(0, 2) == p.ExternalKey.Substring(3, 2))
.ThenBy(p => p.ExternalKey);
sourceLanguages.AddRange(unExactMatchSourceDimensions);
// Add primary language, if current target is primary
if (targetDimension.ExternalKey == defaultLanguage && sourceDefaultDimensionId.HasValue)
{
var sourcePrimaryLanguage = sourceDimensions.FirstOrDefault(p => p.DimensionID == sourceDefaultDimensionId);
if (sourcePrimaryLanguage != null && !sourceLanguages.Contains(sourcePrimaryLanguage))
sourceLanguages.Add(sourcePrimaryLanguage);
}
XElement sourceValue = null;
var readOnly = false;
foreach (var sourceLanguage in sourceLanguages)
{
sourceValue = sourceValues.FirstOrDefault(p => p.Elements("Dimension").Any(d => d.Attribute("DimensionID").Value == sourceLanguage.DimensionID.ToString()));
if (sourceValue == null)
continue;
readOnly = Boolean.Parse(sourceValue.Elements("Dimension").FirstOrDefault(p => p.Attribute("DimensionID").Value == sourceLanguage.DimensionID.ToString()).Attribute("ReadOnly").Value);
// Override ReadOnly for primary target language
if (targetDimension.ExternalKey == defaultLanguage)
readOnly = false;
break;
}
// Take first value if there is only one value wihtout a dimension (default / fallback value), but only in primary language
if (sourceValue == null && sourceValues.Count == 1 && !sourceValues.Elements("Dimension").Any() && targetDimension.ExternalKey == defaultLanguage)
sourceValue = sourceValues.First();
// Process found value
if (sourceValue != null)
{
var dimensionsToAdd = new List<Import.ValueDimension>();
if (targetDimensions.Single(p => p.ExternalKey == targetDimension.ExternalKey).DimensionID >= 1)
dimensionsToAdd.Add(new Import.ValueDimension { DimensionExternalKey = targetDimension.ExternalKey, ReadOnly = readOnly });
// If value has already been added to the list, add just dimension with original ReadOnly state
var existingImportValue = tempTargetValues.FirstOrDefault(p => p.XmlValue == sourceValue);
if (existingImportValue != null)
existingImportValue.Dimensions.AddRange(dimensionsToAdd);
else
{
tempTargetValues.Add(new ImportValue
{
Dimensions = dimensionsToAdd,
XmlValue = sourceValue
});
}
}
}
var currentAttributesImportValues = tempTargetValues.Select(tempImportValue => ValueImportModel.GetModel(tempImportValue.XmlValue.Attribute("Value").Value, tempImportValue.XmlValue.Attribute("Type").Value, tempImportValue.Dimensions, targetEntity)).ToList();
targetValues.Add(sourceAttribute.StaticName, currentAttributesImportValues);
}
targetEntity.Values = targetValues;
return targetEntity;
}
private ImportEntity AppendEntity(Guid entityGuid)
{
var entity = new ImportEntity
{
AttributeSetStaticName = _contentType.StaticName,
AssignmentObjectTypeId = Configuration.AssignmentObjectTypeIdDefault,// SexyContent.SexyContent.AssignmentObjectTypeIDDefault,
EntityGuid = entityGuid,
KeyNumber = null,
Values = new Dictionary<string, List<IValueImportModel>>()
};
Entities.Add(entity);
return entity;
}
private static ImportEntity GetStringAttributeMetaData(string inputType, int? rowCount)
{
var stringEntity = new ImportEntity
{
AttributeSetStaticName = "@String",
Values = new Dictionary<string, List<IValueImportModel>>()
};
if (!string.IsNullOrEmpty(inputType))
stringEntity.Values.Add("InputType", new List<IValueImportModel> { new ValueImportModel<string>(stringEntity) { Value = inputType } });
if (rowCount.HasValue)
stringEntity.Values.Add("RowCount", new List<IValueImportModel> { new ValueImportModel<decimal?>(stringEntity) { Value = rowCount } });
return stringEntity;
}
/// <summary>
/// Import an Entity with all values
/// </summary>
private void PersistOneImportEntity(ImportEntity importEntity)
{
var cache = DataSource.GetCache(null, _context.AppId);
#region try to get AttributeSet or otherwise cancel & log error
// var attributeSet = Context.AttribSet.GetAttributeSet(importEntity.AttributeSetStaticName);
var attributeSet = cache.GetContentType(importEntity.AttributeSetStaticName);
if (attributeSet == null) // AttributeSet not Found
{
_importLog.Add(new ImportLogItem(EventLogEntryType.Error, "AttributeSet not found")
{
ImportEntity = importEntity,
ImportAttributeSet = new ImportAttributeSet {StaticName = importEntity.AttributeSetStaticName}
});
return;
}
#endregion
// Find existing Enties - meaning both draft and non-draft
List<IEntity> existingEntities = null;
if (importEntity.EntityGuid.HasValue)
existingEntities = cache.LightList.Where(e => e.EntityGuid == importEntity.EntityGuid.Value).ToList();
#region Simplest case - add (nothing existing to update)
if (existingEntities == null || !existingEntities.Any())
{
_context.Entities.AddEntity(attributeSet.AttributeSetId, importEntity, _importLog, importEntity.IsPublished, null);
return;
}
#endregion
// todo: 2dm 2016-06-29 check this
#region Another simple case - we have published entities, but are saving unpublished - so we create a new one
if (!importEntity.IsPublished && existingEntities.Count(e => e.IsPublished == false) == 0 && !importEntity.ForceNoBranch)
{
var publishedId = existingEntities.First().EntityId;
_context.Entities.AddEntity(attributeSet.AttributeSetId, importEntity, _importLog, importEntity.IsPublished, publishedId);
return;
}
#endregion
#region Update-Scenario - much more complex to decide what to change/update etc.
#region Do Various Error checking like: Does it really exist, is it not draft, ensure we have the correct Content-Type
// Get existing, published Entity
var editableVersionOfTheEntity = existingEntities.OrderBy(e => e.IsPublished ? 1 : 0).First(); // get draft first, otherwise the published
_importLog.Add(new ImportLogItem(EventLogEntryType.Information, "Entity already exists", importEntity));
#region ensure we don't save a draft is this is not allowed (usually in the case of xml-import)
// Prevent updating Draft-Entity - since the initial would be draft if it has one, this would throw
if (PreventUpdateOnDraftEntities && !editableVersionOfTheEntity.IsPublished)
{
_importLog.Add(new ImportLogItem(EventLogEntryType.Error, "Importing a Draft-Entity is not allowed", importEntity));
return;
}
#endregion
#region Ensure entity has same AttributeSet (do this after checking for the draft etc.
if (editableVersionOfTheEntity.Type.StaticName != importEntity.AttributeSetStaticName)
{
_importLog.Add(new ImportLogItem(EventLogEntryType.Error, "Existing entity (which should be updated) has different ContentType", importEntity));
return;
}
#endregion
#endregion
var newValues = importEntity.Values;
if (_dontUpdateExistingAttributeValues) // Skip values that are already present in existing Entity
newValues = newValues.Where(v => editableVersionOfTheEntity.Attributes.All(ev => ev.Value.Name != v.Key))
.ToDictionary(v => v.Key, v => v.Value);
_context.Entities.UpdateEntity(editableVersionOfTheEntity.RepositoryId, newValues, updateLog: _importLog,
preserveUndefinedValues: _keepAttributesMissingInImport, isPublished: importEntity.IsPublished, forceNoBranch: importEntity.ForceNoBranch);
#endregion
}
public ImportLogItem(EventLogEntryType entryType, string message, ImportEntity importEntity = null)
{
EntryType = entryType;
Message = message;
ImportEntity = importEntity;
}
private ImportEntity CreateImportEntity(EntityWithHeader editInfo, int appId)
{
var newEntity = editInfo.Entity;
var metadata = editInfo.Header.Metadata;
#region initial data quality checks
if (newEntity.Id == 0 && newEntity.Guid == Guid.Empty)
throw new Exception("Item must have a GUID");
#endregion
// TODO 2tk: Refactor code - we use methods from XML import extensions!
var importEntity = new ImportEntity();
#region Guids, Ids, Published, Content-Types
importEntity.EntityGuid = newEntity.Guid;
importEntity.IsPublished = newEntity.IsPublished;
// 2dm 2016-06-29
importEntity.ForceNoBranch = !newEntity.IsBranch; // if it's not a branch, it should also force no branch...
importEntity.AttributeSetStaticName = newEntity.Type.StaticName;
#endregion
#region Metadata if we have any
importEntity.AssignmentObjectTypeId = Constants.DefaultAssignmentObjectTypeId; // default case
if (metadata != null && metadata.HasMetadata)
{
importEntity.AssignmentObjectTypeId = metadata.TargetType;
importEntity.KeyGuid = metadata.KeyGuid;
importEntity.KeyNumber = metadata.KeyNumber;
importEntity.KeyString = metadata.KeyString;
}
#endregion
// Attributes
importEntity.Values = new Dictionary<string, List<IValueImportModel>>();
// only transfer the fields / values which exist in the content-type definition
var attributeSet = DataSource.GetCache(null, appId).GetContentType(newEntity.Type.StaticName);
foreach (var attribute in newEntity.Attributes)
{
var attDef = attributeSet[attribute.Key];
var attributeType = attDef.Type;
// don't save anything of the type empty - this is heading-only
if(attributeType == AttributeTypeEnum.Empty.ToString())
continue;
foreach (var value in attribute.Value.Values)
{
var importValue = importEntity.AppendAttributeValue(attribute.Key, value.Value, attributeType);
if (value.Dimensions == null)
{ // TODO2tk: Must this be done to save entities
importValue.AppendLanguageReference("", false);
continue;
}
foreach (var dimension in value.Dimensions)
{
importValue.AppendLanguageReference(dimension.Key, dimension.Value);
}
}
}
return importEntity;
}
/// <summary>
/// Add ContentTypes for ContentGroup and move all 2sxc data to EAV
/// </summary>
internal void Version070000()
{
logger.LogStep("07.00.00", "Start", false);
var userName = "******";
#region 1. Import new ContentTypes for ContentGroups and Templates
logger.LogStep("07.00.00", "1. Import new ContentTypes for ContentGroups and Templates", false);
if (DataSource.GetCache(Constants.DefaultZoneId, Constants.MetaDataAppId).GetContentType("2SexyContent-Template") == null)
{
var xmlToImport =
File.ReadAllText(HttpContext.Current.Server.MapPath("~/DesktopModules/ToSIC_SexyContent/Upgrade/07.00.00.xml"));
//var xmlToImport = File.ReadAllText("../../../../Upgrade/07.00.00.xml");
var xmlImport = new XmlImport("en-US", userName, true);
var success = xmlImport.ImportXml(Constants.DefaultZoneId, Constants.MetaDataAppId, XDocument.Parse(xmlToImport));
if (!success)
{
var messages = String.Join("\r\n- ", xmlImport.ImportLog.Select(p => p.Message).ToArray());
throw new Exception("The 2sxc module upgrade to 07.00.00 failed: " + messages);
}
}
#endregion
// 2. Move all existing data to the new ContentTypes - Append new IDs to old data (ensures that we can fix things that went wrong after upgrading the module)
#region Prepare Templates
logger.LogStep("07.00.00", "2. Move all existing data to the new ContentTypes - Append new IDs to old data (ensures that we can fix things that went wrong after upgrading the module)", false);
var sqlConnection = new SqlConnection(ConfigurationManager.ConnectionStrings["SiteSqlServer"].ConnectionString);
var templates = new DataTable();
const string sqlCommand = @"SELECT ToSIC_SexyContent_Templates.TemplateID, ToSIC_SexyContent_Templates.PortalID, ToSIC_SexyContent_Templates.Name, ToSIC_SexyContent_Templates.Path,
ToSIC_SexyContent_Templates.AttributeSetID, ToSIC_SexyContent_Templates.DemoEntityID, ToSIC_SexyContent_Templates.Script,
ToSIC_SexyContent_Templates.IsFile, ToSIC_SexyContent_Templates.Type, ToSIC_SexyContent_Templates.IsHidden, ToSIC_SexyContent_Templates.Location,
ToSIC_SexyContent_Templates.UseForList, ToSIC_SexyContent_Templates.UseForItem, ToSIC_SexyContent_Templates.SysCreated,
ToSIC_SexyContent_Templates.SysCreatedBy, ToSIC_SexyContent_Templates.SysModified, ToSIC_SexyContent_Templates.SysModifiedBy,
ToSIC_SexyContent_Templates.SysDeleted, ToSIC_SexyContent_Templates.SysDeletedBy, ToSIC_SexyContent_Templates.AppID,
ToSIC_SexyContent_Templates.PublishData, ToSIC_SexyContent_Templates.StreamsToPublish, ToSIC_SexyContent_Templates.PipelineEntityID,
ToSIC_SexyContent_Templates.ViewNameInUrl, ToSIC_SexyContent_Templates.Temp_PresentationTypeID,
ToSIC_SexyContent_Templates.Temp_PresentationDemoEntityID, ToSIC_SexyContent_Templates.Temp_ListContentTypeID,
ToSIC_SexyContent_Templates.Temp_ListContentDemoEntityID, ToSIC_SexyContent_Templates.Temp_ListPresentationTypeID,
ToSIC_SexyContent_Templates.Temp_ListPresentationDemoEntityID, ToSIC_SexyContent_Templates.Temp_NewTemplateGuid, ToSIC_EAV_Apps.ZoneID,
ToSIC_EAV_Entities_1.EntityGUID AS ContentDemoEntityGuid, ToSIC_EAV_Entities_2.EntityGUID AS PresentationDemoEntityGuid,
ToSIC_EAV_Entities_3.EntityGUID AS ListContentDemoEntityGuid, ToSIC_EAV_Entities_4.EntityGUID AS ListPresentationDemoEntityGuid,
ToSIC_EAV_Entities.EntityGUID AS PipelineEntityGuid
FROM ToSIC_SexyContent_Templates INNER JOIN
ToSIC_EAV_Apps ON ToSIC_SexyContent_Templates.AppID = ToSIC_EAV_Apps.AppID LEFT OUTER JOIN
ToSIC_EAV_Entities ON ToSIC_SexyContent_Templates.PipelineEntityID = ToSIC_EAV_Entities.EntityID LEFT OUTER JOIN
ToSIC_EAV_Entities AS ToSIC_EAV_Entities_3 ON ToSIC_SexyContent_Templates.Temp_ListContentDemoEntityID = ToSIC_EAV_Entities_3.EntityID LEFT OUTER JOIN
ToSIC_EAV_Entities AS ToSIC_EAV_Entities_1 ON ToSIC_SexyContent_Templates.DemoEntityID = ToSIC_EAV_Entities_1.EntityID LEFT OUTER JOIN
ToSIC_EAV_Entities AS ToSIC_EAV_Entities_2 ON
ToSIC_SexyContent_Templates.Temp_PresentationDemoEntityID = ToSIC_EAV_Entities_2.EntityID LEFT OUTER JOIN
ToSIC_EAV_Entities AS ToSIC_EAV_Entities_4 ON ToSIC_SexyContent_Templates.Temp_ListPresentationDemoEntityID = ToSIC_EAV_Entities_4.EntityID
WHERE (ToSIC_SexyContent_Templates.SysDeleted IS NULL) AND ((SELECT COUNT(*) FROM ToSIC_EAV_Entities WHERE EntityGUID = ToSIC_SexyContent_Templates.Temp_NewTemplateGuid) = 0)";
var adapter = new SqlDataAdapter(sqlCommand, sqlConnection);
adapter.SelectCommand.CommandTimeout = 3600;
adapter.Fill(templates);
var existingTemplates = templates.AsEnumerable().Select(t =>
{
var templateId = (int)t["TemplateID"];
var zoneId = (int)t["ZoneID"];
var appId = (int)t["AppID"];
var cache = ((BaseCache)DataSource.GetCache(zoneId, appId)).GetContentTypes();
#region Helper Functions
Func<int?, string> getContentTypeStaticName = contentTypeId =>
{
if (!contentTypeId.HasValue || contentTypeId == 0)
return "";
if (cache.Any(c => c.Value.AttributeSetId == contentTypeId))
return cache[contentTypeId.Value].StaticName;
return "";
};
#endregion
// Create anonymous object to validate the types
var tempTemplate = new
{
TemplateID = templateId,
Name = (string)t["Name"],
Path = (string)t["Path"],
NewEntityGuid = Guid.Parse((string)t["Temp_NewTemplateGuid"]),
//AlreadyImported = t["Temp_NewTemplateGuid"] != DBNull.Value,
ContentTypeId = getContentTypeStaticName(t["AttributeSetID"] == DBNull.Value ? new int?() : (int)t["AttributeSetID"]),
ContentDemoEntityGuids = t["ContentDemoEntityGuid"] == DBNull.Value ? new List<Guid>() : new List<Guid> { (Guid)t["ContentDemoEntityGuid"] },
PresentationTypeId = getContentTypeStaticName((int)t["Temp_PresentationTypeID"]),
PresentationDemoEntityGuids = t["PresentationDemoEntityGuid"] == DBNull.Value ? new List<Guid>() : new List<Guid> { (Guid)t["PresentationDemoEntityGuid"] },
ListContentTypeId = getContentTypeStaticName((int)t["Temp_ListContentTypeID"]),
ListContentDemoEntityGuids = t["ListContentDemoEntityGuid"] == DBNull.Value ? new List<Guid>() : new List<Guid> { (Guid)t["ListContentDemoEntityGuid"] },
ListPresentationTypeId = getContentTypeStaticName((int)t["Temp_ListPresentationTypeID"]),
ListPresentationDemoEntityGuids = t["ListPresentationDemoEntityGuid"] == DBNull.Value ? new List<Guid>() : new List<Guid> { (Guid)t["ListPresentationDemoEntityGuid"] },
Type = (string)t["Type"],
IsHidden = (bool)t["IsHidden"],
Location = (string)t["Location"],
UseForList = (bool)t["UseForList"],
AppId = appId,
PublishData = (bool)t["PublishData"],
StreamsToPublish = (string)t["StreamsToPublish"],
PipelineEntityGuids = t["PipelineEntityGuid"] == DBNull.Value ? new List<Guid>() : new List<Guid> { (Guid)t["PipelineEntityGuid"] },
ViewNameInUrl = t["ViewNameInUrl"].ToString(),
ZoneId = zoneId
};
return tempTemplate;
}).ToList();
#endregion
#region Prepare ContentGroups
logger.LogStep("07.00.00", "2. Prepare Content Groups", false);
var contentGroupItemsTable = new DataTable();
const string sqlCommandContentGroups = @"SELECT DISTINCT ToSIC_SexyContent_ContentGroupItems.ContentGroupItemID, ToSIC_SexyContent_ContentGroupItems.ContentGroupID,
ToSIC_SexyContent_ContentGroupItems.TemplateID, ToSIC_SexyContent_ContentGroupItems.SortOrder, ToSIC_SexyContent_ContentGroupItems.Type,
ToSIC_SexyContent_ContentGroupItems.SysCreated, ToSIC_SexyContent_ContentGroupItems.SysCreatedBy, ToSIC_SexyContent_ContentGroupItems.SysModified,
ToSIC_SexyContent_ContentGroupItems.SysModifiedBy, ToSIC_SexyContent_ContentGroupItems.SysDeleted,
ToSIC_SexyContent_ContentGroupItems.SysDeletedBy, ToSIC_SexyContent_Templates.AppID, ToSIC_EAV_Apps.ZoneID,
ToSIC_EAV_Entities.EntityGUID, ToSIC_SexyContent_ContentGroupItems.EntityID, ToSIC_SexyContent_ContentGroupItems.Temp_NewContentGroupGuid, ToSIC_SexyContent_Templates.Temp_NewTemplateGuid
FROM ToSIC_SexyContent_Templates INNER JOIN
ModuleSettings INNER JOIN
ToSIC_SexyContent_ContentGroupItems ON ModuleSettings.SettingValue = ToSIC_SexyContent_ContentGroupItems.ContentGroupID ON
ToSIC_SexyContent_Templates.TemplateID = ToSIC_SexyContent_ContentGroupItems.TemplateID INNER JOIN
ToSIC_EAV_Apps ON ToSIC_SexyContent_Templates.AppID = ToSIC_EAV_Apps.AppID LEFT OUTER JOIN
ToSIC_EAV_Entities ON ToSIC_SexyContent_ContentGroupItems.EntityID = ToSIC_EAV_Entities.EntityID
WHERE (ToSIC_SexyContent_ContentGroupItems.SysDeleted IS NULL) AND (ModuleSettings.SettingName = N'ContentGroupID') AND
((SELECT COUNT(*) FROM ToSIC_EAV_Entities WHERE EntityGUID = ToSIC_SexyContent_ContentGroupItems.Temp_NewContentGroupGuid) = 0) ORDER BY SortOrder";
var adapterContentGroups = new SqlDataAdapter(sqlCommandContentGroups, sqlConnection);
adapterContentGroups.SelectCommand.CommandTimeout = 3600;
adapterContentGroups.Fill(contentGroupItemsTable);
var contentGroupItems = contentGroupItemsTable.AsEnumerable().Select(c => new
{
ContentGroupId = (int)c["ContentGroupID"],
NewContentGroupGuid = Guid.Parse((string)c["Temp_NewContentGroupGuid"]),
EntityId = c["EntityID"] == DBNull.Value ? new int?() : (int)c["EntityID"],
EntityGuid = c["EntityGUID"] == DBNull.Value ? (Guid?)null : ((Guid)c["EntityGUID"]),
TemplateId = c["TemplateID"] == DBNull.Value ? new int?() : (int)c["TemplateID"],
SortOrder = (int)c["SortOrder"],
Type = (string)c["Type"],
AppId = (int)c["AppID"],
ZoneId = (int)c["ZoneID"],
TemplateEntityGuids = new List<Guid>() { Guid.Parse((string)c["Temp_NewTemplateGuid"]) }
});
var existingContentGroups = contentGroupItems.GroupBy(c => c.ContentGroupId, c => c, (id, items) =>
{
var itemsList = items.ToList();
var contentGroup = new
{
NewEntityGuid = itemsList.First().NewContentGroupGuid,
itemsList.First().AppId,
itemsList.First().ZoneId,
ContentGroupId = id,
TemplateGuids = itemsList.First().TemplateEntityGuids,
ContentGuids = itemsList.Where(p => p.Type == Constants.ContentKey).Select(p => p.EntityGuid).ToList(),
PresentationGuids = itemsList.Where(p => p.Type == Constants.PresentationKey).Select(p => p.EntityGuid).ToList(),
ListContentGuids = itemsList.Where(p => p.Type == "ListContent").Select(p => p.EntityGuid).ToList(),
ListPresentationGuids = itemsList.Where(p => p.Type == "ListPresentation").Select(p => p.EntityGuid).ToList()
};
return contentGroup;
}).ToList();
#endregion
// Import all entities
logger.LogStep("07.00.00", "2. Import all entities", false);
var apps = existingTemplates.Select(p => p.AppId).ToList();
apps.AddRange(existingContentGroups.Select(p => p.AppId));
apps = apps.Distinct().ToList();
foreach (var app in apps)
{
logger.LogStep("07.00.00", "Starting to migrate data for app " + app + "...");
var currentApp = app;
var entitiesToImport = new List<ImportEntity>();
foreach (var t in existingTemplates.Where(t => t.AppId == currentApp))
{
var entity = new ImportEntity
{
AttributeSetStaticName = "2SexyContent-Template",
EntityGuid = t.NewEntityGuid,
IsPublished = true,
AssignmentObjectTypeId = ContentTypeHelpers.AssignmentObjectTypeIDDefault
};
entity.Values = new Dictionary<string, List<IValueImportModel>>
{
{"Name", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.Name }}},
{"Path", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.Path }}},
{"ContentTypeStaticName", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.ContentTypeId }}},
{"ContentDemoEntity", new List<IValueImportModel> {new ValueImportModel<List<Guid>>(entity) { Value = t.ContentDemoEntityGuids }}},
{"PresentationTypeStaticName", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.PresentationTypeId }}},
{"PresentationDemoEntity", new List<IValueImportModel> {new ValueImportModel<List<Guid>>(entity) { Value = t.PresentationDemoEntityGuids }}},
{"ListContentTypeStaticName", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.ListContentTypeId }}},
{"ListContentDemoEntity", new List<IValueImportModel> {new ValueImportModel<List<Guid>>(entity) { Value = t.ListContentDemoEntityGuids }}},
{"ListPresentationTypeStaticName", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.ListPresentationTypeId }}},
{"ListPresentationDemoEntity", new List<IValueImportModel> {new ValueImportModel<List<Guid>>(entity) { Value = t.ListPresentationDemoEntityGuids }}},
{"Type", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.Type }}},
{"IsHidden", new List<IValueImportModel> {new ValueImportModel<bool?>(entity) { Value = t.IsHidden }}},
{"Location", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.Location }}},
{"UseForList", new List<IValueImportModel> {new ValueImportModel<bool?>(entity) { Value = t.UseForList }}},
{"PublishData", new List<IValueImportModel> {new ValueImportModel<bool?>(entity) { Value = t.PublishData }}},
{"StreamsToPublish", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.StreamsToPublish }}},
{"Pipeline", new List<IValueImportModel> {new ValueImportModel<List<Guid>>(entity) { Value = t.PipelineEntityGuids }}},
{"ViewNameInUrl", new List<IValueImportModel> {new ValueImportModel<string>(entity) { Value = t.ViewNameInUrl }}}
};
entitiesToImport.Add(entity);
}
foreach (var t in existingContentGroups.Where(t => t.AppId == app))
{
var entity = new ImportEntity
{
AttributeSetStaticName = "2SexyContent-ContentGroup",
EntityGuid = t.NewEntityGuid,
IsPublished = true,
AssignmentObjectTypeId = ContentTypeHelpers.AssignmentObjectTypeIDDefault
};
entity.Values = new Dictionary<string, List<IValueImportModel>>
{
{"Template", new List<IValueImportModel> {new ValueImportModel<List<Guid>>(entity) { Value = t.TemplateGuids }}},
{Constants.ContentKey, new List<IValueImportModel> {new ValueImportModel<List<Guid?>>(entity) { Value = t.ContentGuids }}},
{Constants.PresentationKey, new List<IValueImportModel> {new ValueImportModel<List<Guid?>>(entity) { Value = t.PresentationGuids }}},
{"ListContent", new List<IValueImportModel> {new ValueImportModel<List<Guid?>>(entity) { Value = t.ListContentGuids }}},
{"ListPresentation", new List<IValueImportModel> {new ValueImportModel<List<Guid?>>(entity) { Value = t.ListPresentationGuids }}}
};
entitiesToImport.Add(entity);
}
var import = new Eav.Import.Import(null, app, userName);
import.RunImport(null, entitiesToImport);
logger.LogStep("07.00.00", "Migrated data for app " + app);
}
logger.LogStep("07.00.00", "Done", false);
}
