public override SCField ConvertValueElement(SCField scField, Guid destFieldId, string elementValue, List <SCItem> destItems = null)
{
if (destItems == null || !destItems.Any())
{
elementValue = string.Empty;
return(base.ConvertValueElement(scField, destFieldId, elementValue, destItems));
}
var itemElements = XmlHelper.GetXmlElementNodeList(elementValue, "item");
if (itemElements == null || itemElements.Count == 0)
{
elementValue = string.Empty;
return(base.ConvertValueElement(scField, destFieldId, elementValue, destItems));
}
var firstSelectedItemValue = itemElements.Item(0)?.InnerXml ?? string.Empty;
var selectedItemId = destItems.FirstOrDefault(i =>
i.TemplateID == new Guid("{B3BDFE59-6667-4432-B261-05D0E3F7FDF6}") && // Item is Extendend List Item
string.Equals(
i.Fields.FirstOrDefault(f => f.FieldId == new Guid("{3A07C171-9BCA-464D-8670-C5703C6D3F11}"))?.Value, // Select Field Value
firstSelectedItemValue, StringComparison.InvariantCultureIgnoreCase))?.ID.ToString("B").ToUpper() ??
string.Empty;
return(CreateFieldFromElement(scField, destFieldId, selectedItemId));
}
public override List <SCField> ConvertValueElementToFields(SCField scField, string elementValue)
{
List <SCField> convertedFields = new List <SCField>();
var decodedElementValue = Uri.UnescapeDataString(elementValue).Replace("+", " ");
var queryElement = XmlHelper.GetXmlElementNode(decodedElementValue, "query");
if (queryElement != null)
{
if (queryElement.Attributes != null && queryElement.Attributes["t"] != null)
{
var queryType = queryElement.Attributes["t"].Value;
if (string.Equals(queryType, "root", StringComparison.InvariantCultureIgnoreCase))
{
string rootItemId = XmlHelper.GetXmlElementValue(queryElement.InnerXml, "value");
string textFieldValue = queryElement.Attributes["tf"]?.Value ?? "__ItemName";
string valueFieldValue = queryElement.Attributes["vf"]?.Value ?? "__ItemName";
// Create fields
var datasourceField = CreateFieldFromElement(scField, new Guid("{5BE76442-950F-4C1F-A797-BEBD71101ABB}"), rootItemId, FieldType.Shared);
if (datasourceField != null)
{
convertedFields.Add(datasourceField);
}
if (!string.IsNullOrEmpty(textFieldValue))
{
var displayField =
CreateFieldFromElement(scField, new Guid("{492361E0-72D8-4847-82BA-EBFC235CF57B}"), textFieldValue, FieldType.Shared);
if (displayField != null)
{
convertedFields.Add(displayField);
}
}
if (!string.IsNullOrEmpty(valueFieldValue))
{
var valueField =
CreateFieldFromElement(scField, new Guid("{78778432-6327-4CEA-A28B-E190E3541D28}"), valueFieldValue, FieldType.Shared);
if (valueField != null)
{
convertedFields.Add(valueField);
}
}
var isDynamicField = CreateFieldFromElement(scField, new Guid("{54424E06-0E7A-47A7-8CB2-7383D700472F}"), "1", FieldType.Shared);
if (isDynamicField != null)
{
convertedFields.Add(isDynamicField);
}
}
}
}
return(convertedFields);
}
public SCField ConvertField(SCField scField, Guid destFieldId)
{
var convertedValue = ConvertValue(scField.Value);
if (convertedValue == null)
{
return(null);
}
return(CreateField(scField, destFieldId, convertedValue));
}
public virtual SCField ConvertValueElement(SCField scField, Guid destFieldId, string elementValue, List <SCItem> destItems = null)
{
var convertedValue = ConvertValue(elementValue);
if (convertedValue == null)
{
return(null);
}
return(CreateFieldFromElement(scField, destFieldId, convertedValue));
}
public List <SCField> CreateFields(MetadataTemplate.MetadataFields.MetadataNewField metadataNewField, Guid itemId, IEnumerable <Tuple <string, int> > langVersions, IEnumerable <string> languages)
{
SCField destField = new SCField();
List <SCField> destFields = new List <SCField>();
var fieldValue = GetValue(metadataNewField.value, metadataNewField.valueType);
switch (metadataNewField.fieldType)
{
case FieldType.Shared:
destField = CreateSharedField(metadataNewField.destFieldId, itemId, fieldValue);
if (destField != null)
{
destFields.Add(destField);
}
break;
case FieldType.Versioned:
foreach (var langVersion in langVersions)
{
if (metadataNewField.values != null)
{
fieldValue = metadataNewField.values[langVersion] ?? fieldValue;
}
destField = CreateVersionedField(metadataNewField.destFieldId, itemId, fieldValue, langVersion.Item2, langVersion.Item1);
if (destField != null)
{
destFields.Add(destField);
}
}
break;
case FieldType.Unversioned:
foreach (var language in languages)
{
var langVersion = new Tuple <string, int>(language, 1);
if (metadataNewField.values != null)
{
fieldValue = metadataNewField.values[langVersion] ?? fieldValue;
}
destField = CreateUnversionedField(metadataNewField.destFieldId, itemId, fieldValue, language);
if (destField != null)
{
destFields.Add(destField);
}
}
break;
//default:
//throw new ArgumentOutOfRangeException(); TODO: To implement meanful error message
}
return(destFields);
}
private void DeleteVersionedField(SCField scField)
{
var dbField = _destMasterDb.VersionedFields.FirstOrDefault(i => i.Id == scField.Id);
if (dbField != null)
{
_destMasterDb.VersionedFields.Remove(dbField);
if (!_appSettings.enableOnlyAnalysisByDefault)
{
_destMasterDb.SaveChanges();
}
}
}
public SCField CreateField(SCField scField, Guid destFieldId, string convertedValue)
{
return(new SCField()
{
Created = DateTime.Now,
Updated = DateTime.Now,
ItemId = scField.ItemId,
Language = scField.Language,
Version = scField.Version,
Type = scField.Type,
Value = convertedValue,
FieldId = destFieldId,
Id = scField.Id
});
}
public SCField CreateFieldFromElement(SCField scField, Guid destFieldId, string convertedValue, FieldType fieldType)
{
return(new SCField()
{
Created = DateTime.UtcNow,
Updated = DateTime.UtcNow,
ItemId = scField.ItemId,
Language = scField.Language,
Version = scField.Version,
Type = fieldType,
Value = convertedValue,
FieldId = destFieldId,
Id = Guid.NewGuid()
});
}
public override List <SCItem> ConvertValueElementToItems(SCField scField, string elementValue, MetadataTemplate metadataTemplate, SCItem sourceItem)
{
List <SCItem> convertedItems = new List <SCItem>();
var decodedElementValue = Uri.UnescapeDataString(elementValue).Replace("+", " ");
var queryElements = XmlHelper.GetXmlElementNodeList(decodedElementValue, "query");
if (queryElements != null && queryElements.Count > 0)
{
foreach (XmlNode queryElement in queryElements)
{
if (queryElement.Attributes != null && queryElement.Attributes["t"] != null)
{
var queryType = queryElement.Attributes["t"].Value;
if (string.Equals(queryType, "default", StringComparison.InvariantCultureIgnoreCase))
{
var value = XmlHelper.GetXmlElementValue(queryElement.InnerXml, "value");
var displayName = value;
var queryChildrenElements = XmlHelper.GetXmlElementNames(queryElement.InnerXml);
foreach (string queryChildrenElementName in queryChildrenElements)
{
if (!string.Equals(queryChildrenElementName, "value", StringComparison.InvariantCultureIgnoreCase))
{
displayName = XmlHelper.GetXmlElementValue(queryElement.InnerXml, queryChildrenElementName);
}
}
if (!string.IsNullOrEmpty(value))
{
// Set item value
metadataTemplate.fields.newFields
.First(field => field.destFieldId == new Guid("{3A07C171-9BCA-464D-8670-C5703C6D3F11}")).value = value;
// Set display name
metadataTemplate.fields.newFields
.First(field => field.destFieldId == new Guid("{B5E02AD9-D56F-4C41-A065-A133DB87BDEB}")).value = displayName;
SCItem convertedItem = _itemFactory.Create(metadataTemplate.destTemplateId, sourceItem, value, metadataTemplate);
convertedItems.Add(convertedItem);
}
}
}
}
}
return(convertedItems);
}
public void AddUnmappedItemField(SCField field, Guid itemId)
{
AddReportingRecord(new ReportingRecord()
{
ItemId = itemId.ToString("B").ToUpper(),
ItemName = _sourceMasterRepository.GetSitecoreItemName(itemId),
ItemPath = _sourceMasterRepository.GetItemPath(itemId),
ItemVersion = field.Version,
ItemLanguage = field.Language,
ItemTemplateId = _sourceMasterRepository.GetItemTemplateId(itemId).ToString("B").ToUpper(),
ItemTemplateName = _sourceMasterRepository.GetSitecoreItemName(_sourceMasterRepository.GetItemTemplateId(itemId)),
FieldId = field.FieldId.ToString("B").ToUpper(),
FieldName = _sourceMasterRepository.GetSitecoreItemName(field.FieldId),
FieldType = field.Type.ToString(),
FieldValue = field.Value,
Message = "Source Field Not Mapped"
});
}
private bool ConvertSourceFieldToSubmitActionItem(SCItem form, Guid sourceFieldId,
string sourceFieldValue, string destItemName, Dictionary <Guid, string> destFieldValues, SCItem buttonItem)
{
SCField sourceFieldToConvert = null;
if (form != null && sourceFieldId != Guid.Empty)
{
sourceFieldToConvert = form.Fields.FirstOrDefault(field => field.FieldId == sourceFieldId);
}
if (sourceFieldToConvert == null || sourceFieldToConvert.Value == sourceFieldValue)
{
CreateSubmitActionItem("SubmitActionDefinition", destItemName, destFieldValues, buttonItem);
return(true);
}
return(false);
}
private void AddOrUpdateSharedField(SCField scField)
{
var fieldCheck = _destMasterDb.SharedFields.FirstOrDefault(field =>
field.FieldId == scField.FieldId && field.ItemId == scField.ItemId);
_destMasterDb.SharedFields.AddOrUpdate(new SharedField()
{
Created = scField.Created,
Updated = scField.Updated,
FieldId = scField.FieldId,
ItemId = scField.ItemId,
Value = scField.Value,
Id = fieldCheck?.Id ?? scField.Id
});
if (!_appSettings.enableOnlyAnalysisByDefault)
{
_destMasterDb.SaveChanges();
}
}
public virtual List <SCItem> ConvertValueElementToItems(SCField scField, string elementValue, MetadataTemplate metadataTemplate, SCItem sourceItem)
{
return(new List <SCItem>());
}
private List <SCItem> ConvertFields(SCItem destItem, SCItem lastDescendantItem)
{
var destFields = new List <SCField>();
var destItems = new List <SCItem>();
var sourceFields = destItem.Fields;
var itemId = sourceFields.First().ItemId;
IEnumerable <Tuple <string, int> > langVersions = sourceFields.Where(f => f.Version != null && f.Language != null).Select(f => new Tuple <string, int>(f.Language, (int)f.Version)).Distinct();
var languages = sourceFields.Where(f => f.Language != null).Select(f => f.Language).Distinct();
// Migrate existing fields
if (_itemMetadataTemplate.fields.existingFields != null)
{
var filteredExistingFields = sourceFields.Where(f =>
_itemMetadataTemplate.fields.existingFields.Select(mf => mf.fieldId).Contains(f.FieldId));
foreach (var filteredExistingField in filteredExistingFields)
{
var existingField =
_itemMetadataTemplate.fields.existingFields.FirstOrDefault(mf => mf.fieldId == filteredExistingField.FieldId);
if (existingField != null)
{
destFields.Add(filteredExistingField);
}
}
}
// Convert fields
if (_itemMetadataTemplate.fields.convertedFields != null)
{
// Select only fields that are mapped
var filteredConvertedFields = sourceFields.Where(f =>
_itemMetadataTemplate.fields.convertedFields.Select(mf => mf.sourceFieldId).Contains(f.FieldId));
foreach (var filteredConvertedField in filteredConvertedFields)
{
var convertedField =
_itemMetadataTemplate.fields.convertedFields.FirstOrDefault(mf =>
mf.sourceFieldId == filteredConvertedField.FieldId);
if (convertedField != null)
{
// Process fields that have multiple dest fields
if (convertedField.destFields != null && convertedField.destFields.Any())
{
var valueElements = new List <string>();
try
{
valueElements = XmlHelper.GetXmlElementNames(filteredConvertedField.Value);
}
catch (Exception ex)
{
_logger.Log(new LogEntry(LoggingEventType.Error, string.Format("ItemConverter - Failed to parse Xml value for form field item. ItemID = {0} - FieldID = {1} - FieldValue_Decoded = {2}", itemId, filteredConvertedField.Id, filteredConvertedField.Value), ex));
}
var filteredValueElementsToMany = convertedField.destFields.Where(f =>
valueElements.Contains(f.sourceElementName.ToLower(), StringComparer.InvariantCultureIgnoreCase) && (f.destFieldId == null || f.destFieldId == Guid.Empty));
foreach (var valueXmlElementMapping in filteredValueElementsToMany)
{
// Special case for List Datasource fields
if (string.Equals(valueXmlElementMapping.sourceElementName, "Items",
StringComparison.InvariantCultureIgnoreCase))
{
IFieldConverter converter = IoC.CreateConverter(valueXmlElementMapping.fieldConverter);
List <SCField> convertedFields = converter?.ConvertValueElementToFields(filteredConvertedField,
XmlHelper.GetXmlElementValue(filteredConvertedField.Value, valueXmlElementMapping.sourceElementName));
if (convertedFields != null && convertedFields.Any())
{
destFields.AddRange(convertedFields);
}
// Delete existing list items
var listItemMetadataTemplate = _metadataProvider.GetItemMetadataByTemplateName("ExtendedListItem");
if (lastDescendantItem != null)
{
var listItems =
_destMasterRepository.GetSitecoreChildrenItems(listItemMetadataTemplate.destTemplateId,
lastDescendantItem.ID);
foreach (SCItem listItem in listItems)
{
_destMasterRepository.DeleteSitecoreItem(listItem);
}
}
List <SCItem> convertedItems = converter?.ConvertValueElementToItems(filteredConvertedField,
XmlHelper.GetXmlElementValue(filteredConvertedField.Value, valueXmlElementMapping.sourceElementName),
listItemMetadataTemplate, lastDescendantItem ?? destItem);
if (convertedItems != null && convertedItems.Any())
{
destItems.AddRange(convertedItems);
}
// Reporting
if (convertedFields?.Count > 0 && convertedItems?.Count > 0)
{
_conversionReporter.AddUnmappedValueElementSourceField(filteredConvertedField, itemId, valueXmlElementMapping.sourceElementName, XmlHelper.GetXmlElementValue(filteredConvertedField.Value, valueXmlElementMapping.sourceElementName));
}
}
}
var filteredValueElements =
convertedField.destFields.Where(f => valueElements.Contains(f.sourceElementName.ToLower(), StringComparer.InvariantCultureIgnoreCase) && (f.destFieldId != null && f.destFieldId != Guid.Empty));
foreach (var valueXmlElementMapping in filteredValueElements)
{
IFieldConverter converter = IoC.CreateConverter(valueXmlElementMapping.fieldConverter);
SCField destField = converter?.ConvertValueElement(filteredConvertedField, (Guid)valueXmlElementMapping.destFieldId, XmlHelper.GetXmlElementValue(filteredConvertedField.Value, valueXmlElementMapping.sourceElementName), destItems);
if (destField != null && destField.FieldId != Guid.Empty)
{
destFields.Add(destField);
}
}
// Reporting
var unmappedValueElementSourceFields = valueElements.Where(v =>
!convertedField.destFields.Select(f => f.sourceElementName)
.Contains(v, StringComparer.InvariantCultureIgnoreCase));
foreach (var unmappedValueElementSourceField in unmappedValueElementSourceFields)
{
_conversionReporter.AddUnmappedValueElementSourceField(filteredConvertedField, itemId, unmappedValueElementSourceField, XmlHelper.GetXmlElementValue(filteredConvertedField.Value, unmappedValueElementSourceField));
}
}
// Process fields that have a single dest field
else if (convertedField.destFieldId != null && convertedField.destFieldId != Guid.Empty)
{
IFieldConverter converter = IoC.CreateConverter(convertedField.fieldConverter);
SCField destField = converter?.ConvertField(filteredConvertedField, (Guid)convertedField.destFieldId);
if (destField != null && destField.FieldId != Guid.Empty)
{
destFields.Add(destField);
}
}
}
}
}
if (_itemMetadataTemplate.fields.newFields != null)
{
// Create new fields
foreach (var newField in _itemMetadataTemplate.fields.newFields)
{
destFields.AddRange(_fieldFactory.CreateFields(newField, itemId, langVersions, languages));
}
}
destItem.Fields = destFields;
destItems.Add(destItem);
// Merge multi-language List items with same value
destItems = MergeListItems(destItems);
// Reporting
var unmappedSourceFields = sourceFields?.Where(f => (_itemMetadataTemplate.fields.existingFields == null || !_itemMetadataTemplate.fields.existingFields.Select(mf => mf.fieldId).Contains(f.FieldId)) &&
(_itemMetadataTemplate.fields.convertedFields == null || !_itemMetadataTemplate.fields.convertedFields.Select(mf => mf.sourceFieldId).Contains(f.FieldId)));
foreach (SCField unmappedSourceField in unmappedSourceFields)
{
_conversionReporter.AddUnmappedItemField(unmappedSourceField, itemId);
}
return(destItems);
}
public override List <SCItem> ConvertValueElementToItems(SCField scField, string elementValue, MetadataTemplate metadataTemplate, SCItem sourceItem)
{
List <SCItem> convertedItems = new List <SCItem>();
var decodedElementValue = Uri.UnescapeDataString(elementValue).Replace("+", " ");
XmlNodeList queryElements = null;
try
{
queryElements = XmlHelper.GetXmlElementNodeList(decodedElementValue, "query", true);
}
catch (Exception ex)
{
_logger.Log(new LogEntry(LoggingEventType.Error,
string.Format("ConvertValueElementToItems - Failed to parse Xml value. ItemID = {0} - FieldID = {1} - ElementName = {2} - ElementValue_Decoded = {3}",
scField.ItemId, scField.Id, "query", decodedElementValue), ex));
}
if (queryElements != null && queryElements.Count > 0)
{
foreach (XmlNode queryElement in queryElements)
{
if (queryElement.Attributes != null && queryElement.Attributes["t"] != null)
{
var queryType = queryElement.Attributes["t"].Value;
if (string.Equals(queryType, "default", StringComparison.InvariantCultureIgnoreCase))
{
var value = XmlHelper.GetXmlElementValue(queryElement.InnerXml, "value");
var displayName = value;
var displayNames = new Dictionary <Tuple <string, int>, string>();
var queryChildrenElements = XmlHelper.GetXmlElementNames(queryElement.InnerXml);
foreach (string queryChildrenElementName in queryChildrenElements)
{
if (!string.Equals(queryChildrenElementName, "value", StringComparison.InvariantCultureIgnoreCase))
{
displayName = XmlHelper.GetXmlElementValue(queryElement.InnerXml, queryChildrenElementName);
displayNames.Add(new Tuple <string, int>(queryChildrenElementName, 1), displayName);
}
}
if (!string.IsNullOrEmpty(value))
{
// Set item value
metadataTemplate.fields.newFields
.First(field => field.destFieldId == new Guid("{3A07C171-9BCA-464D-8670-C5703C6D3F11}")).value = value;
// Set display name
if (displayNames.Any())
{
metadataTemplate.fields.newFields
.First(field => field.destFieldId == new Guid("{B5E02AD9-D56F-4C41-A065-A133DB87BDEB}")).values = displayNames;
}
else
{
metadataTemplate.fields.newFields
.First(field => field.destFieldId == new Guid("{B5E02AD9-D56F-4C41-A065-A133DB87BDEB}")).value = displayName;
}
SCItem convertedItem = _itemFactory.Create(metadataTemplate.destTemplateId, sourceItem, value, metadataTemplate);
convertedItems.Add(convertedItem);
}
}
}
}
}
return(convertedItems);
}
public SCField CreateFieldFromElement(SCField scField, Guid destFieldId, string convertedValue)
{
return(CreateFieldFromElement(scField, destFieldId, convertedValue, scField.Type));
}
public virtual List <SCField> ConvertValueElementToFields(SCField scField, string elementValue)
{
return(new List <SCField>());
}
