public static IFieldConverter GetDataSource(Column field)
{
IFieldConverter result = null;
if (field.Type.ToLower() == "bit")
{
result = new EnumDataSource()
{
EnumTypeFullName = typeof(YesOrNo).FullName
};
}
if (field.Name.IndexOf("UserId") >= 0 || field.Name.IndexOf("Creator") >= 0)
{
result = new EntityDataSource()
{
EntityType = typeof(User)
};
}
if (field.Name.IndexOf("DepartmentId") >= 0)
{
result = new EntityDataSource()
{
EntityType = typeof(Department)
};
}
return(result);
}
/// <summary>
/// Convert field
/// </summary>
/// <param name="server">Database server</param>
/// <param name="conversionOptions">Field conversion options</param>
/// <param name="objectName">Object name</param>
/// <param name="fieldName">Field name</param>
/// <returns>Return field conversion result</returns>
internal static FieldConversionResult ConvertField(DatabaseServer server, FieldConversionOptions conversionOptions, string objectName, string fieldName)
{
if (string.IsNullOrWhiteSpace(conversionOptions?.ConversionName))
{
return(null);
}
IFieldConverter fieldConverter = DataManager.GetFieldConverter(conversionOptions.ConversionName) ?? DefaultFieldConverter;
return(fieldConverter.Convert(new FieldConversionContext()
{
ConversionName = conversionOptions.ConversionName,
Parameter = conversionOptions.Parameter,
FieldName = fieldName,
ObjectName = objectName,
Server = server
}));
}
public PropertyContext(PropertyInfo property,
string tag,
IFieldConverter converter)
{
if (property == null)
{
throw new ArgumentNullException(nameof(property));
}
if (string.IsNullOrEmpty(tag))
{
throw new ArgumentNullException(nameof(tag));
}
if (converter == null)
{
throw new ArgumentNullException(nameof(converter));
}
Property = property;
Tag = tag;
Converter = converter;
}
public static FilterParams BuildFilter <C>(C obj, IFieldConverter <C> converter)
where C : class
{
var ret = new FilterParams();
foreach (PropertyDescriptor p in TypeDescriptor.GetProperties(obj))
{
var val = p.GetValue(obj);
if (val == null || val.ToString().Length == 0)
{
continue;
}
if (val is long? && (!(val as long?).HasValue || (val as long?).Value == 0))
{
continue;
}
if (val is long && (long)val == 0)
{
continue;
}
if (val is int && (int)val == 0)
{
continue;
}
if (val is short && (short)val == 0)
{
continue;
}
var field = converter.Match(p.Name);
if (field == null)
{
continue;
}
AddExpression(ret, field.Item1, val, field.Item2);
}
return(ret);
}
public FieldConverterWrapper(Type converterType, IFieldConverter converterInstance)
{
ConverterType = converterType;
ConverterInstance = converterInstance;
}
public FieldConverterWrapper(Type converterType, IFieldConverter converterInstance)
{
ConverterType = converterType;
ConverterInstance = converterInstance;
}
private void ConvertSaveActions(SCItem form, string tracking, SCItem buttonItem, bool saveToDatabaseActionCreated)
{
var formSaveActionField = form.Fields
.FirstOrDefault(field => field.FieldId == new Guid(FormConstants.FormSaveActionFieldId));
var formSaveActions = formSaveActionField?.Value;
if (!string.IsNullOrEmpty(formSaveActions))
{
var saveActionElements = XmlHelper.GetXmlElementNodeList(XmlHelper.GetXmlElementNode(formSaveActions, "g").InnerXml, "li");
List <SaveAction> saveActionItems = new List <SaveAction>();
if (saveActionElements != null)
{
foreach (XmlNode saveActionElement in saveActionElements)
{
if (saveActionElement.Attributes != null)
{
var saveAction = new SaveAction()
{
Id = saveActionElement.Attributes["id"].Value,
UnicId = saveActionElement.Attributes["unicid"].Value,
Parameters = XmlHelper.GetXmlElementValue(saveActionElement.InnerXml, "parameters")
};
saveActionItems.Add(saveAction);
}
}
foreach (var saveActionItem in saveActionItems)
{
if (saveActionItem.Id == FormConstants.FormSaveAction_RegisterCampaignValue)
{
var trackingCampaign = XmlHelper.GetXmlElementNodeList(tracking, "campaign");
var xmlAttributeCollection = trackingCampaign[0].Attributes;
if (xmlAttributeCollection != null)
{
var trackingCampaignId = trackingCampaign.Count > 0 ? xmlAttributeCollection["id"]?.Value : null;
if (trackingCampaignId != null)
{
if (!_appSettings.enableReferencedItemCheck || _destMasterRepository.ItemExists(new Guid(trackingCampaignId)))
{
// Create Trigger Campaign Activity Save Action
var triggerCampaignActivityValues = new Dictionary <Guid, string>();
triggerCampaignActivityValues.Add(new Guid(SubmitActionConstants.SubmitActionFieldId),
SubmitActionConstants.SubmitActionField_TriggerCampaignActivityActionValue);
triggerCampaignActivityValues.Add(new Guid(SubmitActionConstants.ParametersFieldId),
string.Format("{{\"referenceId\":\"{0}\"}}", trackingCampaignId));
ConvertFieldsToSubmitActionItem("Trigger Campaign Activity", triggerCampaignActivityValues, buttonItem);
}
}
}
}
else if (!saveToDatabaseActionCreated && saveActionItem.Id == FormConstants.FormSaveAction_SaveToDatabaseValue)
{
ConvertSaveDataAction(form, buttonItem);
}
else
{
// Convert other save actions if mapped in AppSettings.json
var submitAction =
_appSettings.submitActions.FirstOrDefault(s => s.sourceSaveActionId == Guid.Parse(saveActionItem.Id));
if (submitAction != null)
{
IFieldConverter converter = IoC.CreateInstance(submitAction.destParametersConverterType);
var submitActionValues = new Dictionary <Guid, string>();
submitActionValues.Add(new Guid(SubmitActionConstants.SubmitActionFieldId),
submitAction.destSubmitActionFieldValue);
try
{
submitActionValues.Add(new Guid(SubmitActionConstants.ParametersFieldId),
converter.ConvertValue(
HttpUtility.HtmlDecode((saveActionItem.Parameters.Replace("&", "&")))));
}
catch (Exception ex)
{
_logger.Log(new LogEntry(LoggingEventType.Error,
string.Format("SubmitConverter - Failed to parse Xml value of Parameters field of Submit Action. FormID = {0} - FieldID = {1} - FieldValue = {2}",
form.ID, formSaveActionField.Id, saveActionItem.Parameters), ex));
}
var destSubmitActionItemId = ConvertFieldsToSubmitActionItem(submitAction.destSubmitActionItemName, submitActionValues, buttonItem);
// Only if Save Action is Send Email
if (submitAction.sourceSaveActionId == Guid.Parse(FormConstants.FormSaveAction_SendEmailValue))
{
CreateAddressBookSender(destSubmitActionItemId);
}
}
else
{
_analysisReporter.AddUnmappedSaveAction(formSaveActionField, form.ID, Guid.Parse(saveActionItem.Id));
}
}
}
}
}
}
public override string Render()
{
if (Visiable)
{
AddAttributes();
var texts = new List <string>();
if (TextID.IsNullOrEmpty())
{
TextID = "{0}_Text".FormatTo(Id);
}
if (!Value.IsNullOrEmpty() && !SelectType.IsNullOrEmpty())
{
var page = PageBuilder.BuildPage(SelectType);
if (page != null && page.Controls.Count > 0)
{
IFieldConverter listDs = null;
page.Controls.ForEach((o) =>
{
if (o is IListDataSourceControl)
{
listDs = (o as IListDataSourceControl).DataSource as IFieldConverter;
return;
}
else if (o is ICascadeDataSourceControl)
{
listDs = (o as ICascadeDataSourceControl).DataSource as IFieldConverter;
return;
}
});
if (listDs != null)
{
if (IsMulitle)
{
foreach (var v in Value.Split(','))
{
texts.Add(listDs.Converter(Id, v, null).ToString());
}
}
else
{
texts.Add(listDs.Converter(Id, Value, null).ToString());
}
}
}
}
string text = string.Empty;
if (texts.Count > 0)
{
text = string.Join(",", texts.ToArray());
}
var textBox = new TextBox()
{
Id = TextID, Name = TextID, Value = text
};
if (!Attributes.IsNullOrEmpty())
{
foreach (var attr in Attributes)
{
textBox.Attributes[attr.Key] = attr.Value;
}
}
textBox.Attributes["data-selector"] = SelectType;
textBox.Attributes["data-showtype"] = ShowType.ToString();
textBox.Attributes["data-multiple"] = IsMulitle.ToString().ToLower();
textBox.Attributes["data-target"] = Id;
textBox.Attributes["data-dialogheight"] = DialogHeight.ToString();
textBox.Attributes["data-dialogwidth"] = DialogWidth.ToString();
var hidden = new HiddenField()
{
Id = Id, Name = Id, Value = Value, Validator = Validator
};
string result = hidden.Render() + textBox.Render();
return(ContainerTemplate.FormatTo(Id, Label, result, Description));
}
return(string.Empty);
}
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);
}
/// <summary>
/// Throws a ConvertException with the passed values
/// </summary>
/// <param name="converter">IField converter instance</param>
/// <param name="from">The source string.</param>
/// <param name="errorMessage" >The custom error msg.</param>
/// <exception cref="ConvertException">Throw exception with values</exception>
public static void ThrowConvertException(this IFieldConverter converter, string from, string errorMessage)
{
throw new ConvertException(from, converter?.Type, errorMessage);
}
