void UpdateFieldStatusIconAndStyling(VisualElement field, FieldValueInfo valueInfo)
{
var statusIndicator = field.GetFieldStatusIndicator();
void ClearClassLists(VisualElement ve)
{
ve.RemoveFromClassList(BuilderConstants.InspectorLocalStyleDefaultStatusClassName);
ve.RemoveFromClassList(BuilderConstants.InspectorLocalStyleInheritedClassName);
ve.RemoveFromClassList(BuilderConstants.InspectorLocalStyleSelectorClassName);
ve.RemoveFromClassList(BuilderConstants.InspectorLocalStyleVariableClassName);
ve.RemoveFromClassList(BuilderConstants.InspectorLocalStyleUnresolvedVariableClassName);
};
ClearClassLists(field);
ClearClassLists(statusIndicator);
var statusClassName = valueInfo.valueBinding.type switch
{
FieldValueBindingInfoType.USSVariable => valueInfo.valueBinding.variable.sheet != null
? BuilderConstants.InspectorLocalStyleVariableClassName
: BuilderConstants.InspectorLocalStyleUnresolvedVariableClassName,
_ => valueInfo.valueSource.type switch
{
FieldValueSourceInfoType.Inherited => BuilderConstants.InspectorLocalStyleInheritedClassName,
FieldValueSourceInfoType.MatchingUSSSelector => BuilderConstants.InspectorLocalStyleSelectorClassName,
_ => BuilderConstants.InspectorLocalStyleDefaultStatusClassName
}
};
statusIndicator.AddToClassList(statusClassName);
field.AddToClassList(statusClassName);
}
/// <summary>
/// Writes a taxonomy field value to a SPListItem.
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var termInfo = fieldValueInfo.Value as TaxonomyValue;
TaxonomyFieldValue newTaxonomyFieldValue = null;
TaxonomyField taxonomyField = (TaxonomyField)item.Fields.GetField(fieldValueInfo.FieldInfo.InternalName);
newTaxonomyFieldValue = new TaxonomyFieldValue(taxonomyField);
var noteField = item.Fields[taxonomyField.TextField];
if (termInfo != null && termInfo.Term != null)
{
string labelGuidPair = TaxonomyItem.NormalizeName(termInfo.Term.Label) + TaxonomyField.TaxonomyGuidLabelDelimiter + termInfo.Term.Id.ToString().ToUpperInvariant();
// PopulateFromLabelGuidPair takes care of looking up the WssId value and creating a new item in the TaxonomyHiddenList if needed.
// Main taxonomy field value format: WssID;#Label
// TODO - Make sure we support sub-level terms with format: WssID;#Label|RootTermGuid|...|ParentTermGuid|TermGuid
// Reference: http://msdn.microsoft.com/en-us/library/ee567833.aspx
newTaxonomyFieldValue.PopulateFromLabelGuidPair(labelGuidPair);
// Must write associated note field as well as the main taxonomy field.
// Note field value format: Label|Guid
// Reference: http://nickhobbs.wordpress.com/2012/02/21/sharepoint-2010-how-to-set-taxonomy-field-values-programmatically/
item[noteField.InternalName] = labelGuidPair;
}
else
{
// No taxonomy value, make sure to empty the note field as well
item[noteField.InternalName] = null;
}
item[fieldValueInfo.FieldInfo.InternalName] = newTaxonomyFieldValue;
}
/// <summary>
/// Writes a Taxonomy Multi field value to a SPListItem
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var termInfos = fieldValueInfo.Value as TaxonomyValueCollection;
TaxonomyFieldValueCollection newTaxonomyFieldValueCollection = null;
TaxonomyField taxonomyField = (TaxonomyField)item.Fields.GetField(fieldValueInfo.FieldInfo.InternalName);
var noteField = item.Fields[taxonomyField.TextField];
if (termInfos != null && termInfos.Count > 0)
{
List <string> labelGuidPairsListOutParam = new List <string>();
newTaxonomyFieldValueCollection = CreateSharePointTaxonomyFieldValue(taxonomyField, termInfos, labelGuidPairsListOutParam);
item[taxonomyField.Id] = newTaxonomyFieldValueCollection;
// Must write associated note field as well as the main taxonomy field.
// Note field value format: Label|Guid;Label|Guid;Label|Guid...
// Reference: http://nickhobbs.wordpress.com/2012/02/21/sharepoint-2010-how-to-set-taxonomy-field-values-programmatically/
string labelGuidPairsAsString = string.Join(";", labelGuidPairsListOutParam.ToArray());
item[noteField.InternalName] = labelGuidPairsAsString;
}
else
{
// No taxonomy value, make sure to empty the note field as well
item[noteField.InternalName] = null;
}
item[fieldValueInfo.FieldInfo.InternalName] = newTaxonomyFieldValueCollection;
}
/// <summary>
/// Writes a field value as an SPFolder's default column value
/// </summary>
/// <param name="folder">The folder for which we wish to update a field's default value</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (UrlValue)fieldValueInfo.Value;
MetadataDefaults listMetadataDefaults = new MetadataDefaults(folder.ParentWeb.Lists[folder.ParentListId]);
if (defaultValue != null)
{
var sharePointFieldUrlValue = new SPFieldUrlValue {
Url = defaultValue.Url, Description = defaultValue.Description
};
this.log.Warn(
"WriteValueToFolderDefault - Initializing {0} field (fieldName={1}) with default value \"{2}\"."
+ " Be aware that folder default values on {0}-type field are not well supported by SharePoint and that this default"
+ " value will not be editable through your document library's \"List Settings > Column default value settings\" options page.",
fieldValueInfo.FieldInfo.FieldType,
fieldValueInfo.FieldInfo.InternalName,
sharePointFieldUrlValue.ToString());
listMetadataDefaults.SetFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName, sharePointFieldUrlValue.ToString());
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
/// <summary>
/// Writes a Principal field value to a SPListItem
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var principal = fieldValueInfo.Value as PrincipalValue;
var newValue = principal != null?FormatPrincipalString(principal) : null;
item[fieldValueInfo.FieldInfo.InternalName] = newValue;
}
public void UpdateFieldStatus(VisualElement field, StyleProperty property)
{
var valueInfo = FieldValueInfo.Get(this, field, property);
field.SetProperty(BuilderConstants.InspectorFieldValueInfoVEPropertyName, valueInfo);
UpdateFieldStatusIconAndStyling(field, valueInfo);
UpdateFieldTooltip(field, valueInfo);
}
/// <summary>
/// Writes a field value as an SPFolder's default column value
/// </summary>
/// <param name="folder">The folder for which we wish to update a field's default value</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
"WriteValueToFolderDefault - Initializing a folder column default value with LookupValue is not supported (fieldName={0}).",
fieldValueInfo.FieldInfo.InternalName));
}
/// <summary>
/// Writes a user field value to a SPListItem
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var userValueColl = fieldValueInfo.Value as UserValueCollection;
var newUserValue = userValueColl != null
? CreateSharePointUserValueCollection(item.Web, userValueColl).ToString()
: null;
item[fieldValueInfo.FieldInfo.InternalName] = newUserValue;
}
/// <summary>
/// Writes a url field value to a SPListItem
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var urlValue = fieldValueInfo.Value as UrlValue;
var newUrlValue = urlValue != null ? new SPFieldUrlValue {
Url = urlValue.Url, Description = urlValue.Description
} : null;
item[fieldValueInfo.FieldInfo.InternalName] = newUrlValue;
}
/// <summary>
/// Writes a standard field value as an SPFolder's default value
/// </summary>
/// <param name="folder">The folder for which we wish to update the default value</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (bool?)fieldValueInfo.Value;
MetadataDefaults listMetadataDefaults = new MetadataDefaults(folder.ParentWeb.Lists[folder.ParentListId]);
var parentList = folder.ParentWeb.Lists[folder.ParentListId];
var listField = parentList.Fields[fieldValueInfo.FieldInfo.Id];
// Pages library is a special case: attempting to set default value to TRUE will
// always fail because of patchy OOTB support.
if ((int)parentList.BaseTemplate == BuiltInListTemplates.Pages.ListTempateTypeId &&
defaultValue.HasValue &&
defaultValue.Value)
{
string exceptionMessage = "WriteValueToFolderDefault - Impossible to set folder default value as TRUE"
+ " within the Pages library. That column default would be ignored. (fieldName={0})";
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
exceptionMessage,
fieldValueInfo.FieldInfo.InternalName));
}
if (!string.IsNullOrEmpty(listField.DefaultValue) &&
bool.Parse(listField.DefaultValue) &&
defaultValue.HasValue &&
!defaultValue.Value)
{
// The SPField already has a default value set to TRUE. Our folder column default FALSE will have no
// effect because the field definition's default will always be applied. Thanks SharePoint!
string exceptionMessage = "WriteValueToFolderDefault - The field {0} already has a DefaultValue=TRUE definition."
+ " Your attempt to define a folder column default with value=FALSE would not work, since the TRUE"
+ " value imposed by the SPField's DefaultValue will always \"win\" and be applied instead.";
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
exceptionMessage,
fieldValueInfo.FieldInfo.InternalName));
}
if (defaultValue.HasValue)
{
listMetadataDefaults.SetFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName, defaultValue.Value.ToString());
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
/// <summary>
/// Writes an image field value to a SPListItem
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var imageValue = fieldValueInfo.Value as ImageValue;
ImageFieldValue sharePointFieldImageValue = null;
if (imageValue != null)
{
sharePointFieldImageValue = CreateSharePointImageFieldValue(imageValue);
}
item[fieldValueInfo.FieldInfo.InternalName] = sharePointFieldImageValue;
}
/// <summary>
/// Writes a string field value to a SPListItem
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var typedFieldValue = (DateTime?)fieldValueInfo.Value;
if (typedFieldValue.HasValue)
{
item[fieldValueInfo.FieldInfo.InternalName] = typedFieldValue.Value;
}
else
{
item[fieldValueInfo.FieldInfo.InternalName] = null;
}
}
/// <summary>
/// Writes an image field value to a SPListItem
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var mediaValue = fieldValueInfo.Value as MediaValue;
MediaFieldValue sharePointFieldMediaValue = null;
if (mediaValue != null)
{
sharePointFieldMediaValue = CreateSharePointMediaFieldValue(mediaValue);
}
item[fieldValueInfo.FieldInfo.InternalName] = sharePointFieldMediaValue;
}
/// <summary>
/// Provided a field cref value, fetches the field value using reflection.
/// </summary>
/// <param name="crefValue">The cref value for the field.</param>
/// <param name="crefFieldMap">The cref value to <see cref="FieldValueInfo"/> map.</param>
/// <param name="typeFetcher">The type fetcher used to fetch field value from the loaded assemblies.</param>
private void BuildCrefFieldValueMap(
string crefValue,
Dictionary <string, FieldValueInfo> crefFieldMap,
TypeFetcher typeFetcher)
{
if (string.IsNullOrWhiteSpace(crefValue) || crefFieldMap.ContainsKey(crefValue))
{
return;
}
var fieldValueInfo = new FieldValueInfo();
try
{
var typeName = crefValue.ExtractTypeNameFromFieldCref();
var type = typeFetcher.LoadTypeFromCrefValues(new List <string> {
typeName
});
var fieldName = crefValue.ExtractFieldNameFromCref();
var fields = type.GetFields(BindingFlags.Public | BindingFlags.Static);
var field = fields.FirstOrDefault(f => f.Name == fieldName);
if (field == null)
{
var errorMessage = string.Format(
SpecificationGenerationMessages.FieldNotFound,
fieldName,
typeName);
throw new TypeLoadException(errorMessage);
}
fieldValueInfo.Value = field.GetValue(null).ToString();
}
catch (Exception e)
{
var error = new GenerationError
{
ExceptionType = e.GetType().Name,
Message = e.Message
};
fieldValueInfo.Error = error;
}
crefFieldMap.Add(crefValue, fieldValueInfo);
}
/// <summary>
/// Updates the specified SPFolder with new default field value
/// </summary>
/// <param name="folder">The SharePoint folder for which we want to update the metadata defaults.</param>
/// <param name="defaultFieldValueInfo">The default value to be applied to items created within that folder.</param>
public void WriteValuesToFolderDefault(SPFolder folder, FieldValueInfo defaultFieldValueInfo)
{
if (folder == null)
{
throw new ArgumentNullException("folder");
}
if (defaultFieldValueInfo == null || defaultFieldValueInfo.FieldInfo == null)
{
throw new ArgumentNullException("defaultFieldValueInfo");
}
IBaseValueWriter valueWriter = this.GetWriter(defaultFieldValueInfo);
valueWriter.WriteValueToFolderDefault(folder, defaultFieldValueInfo);
}
/// <summary>
/// Updates the given SPListItem with the value passed.
/// This method does not call Update or SystemUpdate.
/// </summary>
/// <param name="item">The SharePoint list item to update.</param>
/// <param name="fieldValueInfo">The value information to be updated in the SPListItem.</param>
public void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (fieldValueInfo == null || fieldValueInfo.FieldInfo == null)
{
throw new ArgumentNullException("fieldValueInfo");
}
IBaseValueWriter valueWriter = this.GetWriter(fieldValueInfo);
valueWriter.WriteValueToListItem(item, fieldValueInfo);
}
/// <summary>
/// Writes a standard field value as an SPFolder's default value
/// </summary>
/// <param name="folder">The folder for which we wish to update the column metadata defaults</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (Guid?)fieldValueInfo.Value;
MetadataDefaults listMetadataDefaults = new MetadataDefaults(folder.ParentWeb.Lists[folder.ParentListId]);
if (defaultValue.HasValue)
{
listMetadataDefaults.SetFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName, defaultValue.Value.ToString());
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
/// <summary>
/// Writes a standard field value as an SPFolder's default value
/// </summary>
/// <param name="folder">The folder for which we wish to update the column metadata defaults</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (string)fieldValueInfo.Value;
MetadataDefaults listMetadataDefaults = new MetadataDefaults(folder.ParentWeb.Lists[folder.ParentListId]);
var parentList = folder.ParentWeb.Lists[folder.ParentListId];
// Pages library is a special case: attempting to set folder default value on any text-based field (Text, Note or HTML)
// will always fail because of patchy OOTB support.
if ((int)parentList.BaseTemplate == BuiltInListTemplates.Pages.ListTempateTypeId &&
!string.IsNullOrEmpty(defaultValue))
{
string exceptionMessage = "WriteValueToFolderDefault - Impossible to set folder default value (val={0}) on field {1} of type {2}"
+ " within the Pages library. That column default would be ignored.";
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
exceptionMessage,
defaultValue,
fieldValueInfo.FieldInfo.InternalName,
fieldValueInfo.FieldInfo.FieldType));
}
if (defaultValue != null)
{
if (fieldValueInfo.FieldInfo is NoteFieldInfo || fieldValueInfo.FieldInfo is HtmlFieldInfo)
{
this.log.Warn(
"WriteValueToFolderDefault - Initializing {0} field (fieldName={1}) with default value \"{2}\"."
+ " Be aware that folder default values on {0}-type field are not well supported by SharePoint and that this default"
+ " value will not be editable through your document library's \"List Settings > Column default value settings\" options page.",
fieldValueInfo.FieldInfo.FieldType,
fieldValueInfo.FieldInfo.InternalName,
defaultValue);
}
listMetadataDefaults.SetFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName, defaultValue);
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
/// <summary>
/// Writes a field value as an SPFolder's default column value
/// </summary>
/// <param name="folder">The folder for which we wish to update a field's default value</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (TaxonomyValue)fieldValueInfo.Value;
var list = folder.ParentWeb.Lists[folder.ParentListId];
var taxonomyField = (TaxonomyField)list.Fields[fieldValueInfo.FieldInfo.Id];
MetadataDefaults listMetadataDefaults = new MetadataDefaults(list);
if (defaultValue != null)
{
listMetadataDefaults.SetFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName, FormatTaxonomyString(taxonomyField, defaultValue));
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
static string GetFieldStatusIndicatorTooltip(FieldValueInfo info)
{
if (info.valueSource.type == FieldValueSourceInfoType.Default)
{
return(BuilderConstants.FieldStatusIndicatorDefaultTooltip);
}
if (info.valueBinding.type == FieldValueBindingInfoType.USSVariable)
{
return(info.valueBinding.variable.sheet != null ? BuilderConstants.FieldStatusIndicatorVariableTooltip : BuilderConstants.FieldStatusIndicatorUnresolvedVariableTooltip);
}
return(info.valueSource.type switch
{
FieldValueSourceInfoType.Inline => BuilderConstants.FieldStatusIndicatorInlineTooltip,
FieldValueSourceInfoType.Inherited => BuilderConstants.FieldStatusIndicatorInheritedTooltip,
FieldValueSourceInfoType.MatchingUSSSelector => BuilderConstants.FieldStatusIndicatorFromSelectorTooltip,
FieldValueSourceInfoType.LocalUSSSelector => BuilderConstants.FieldStatusIndicatorLocalTooltip,
_ => null
});
private IBaseValueWriter GetWriter(FieldValueInfo fieldValueInfo)
{
var associatedValueType = fieldValueInfo.FieldInfo.AssociatedValueType;
IBaseValueWriter valueWriter = null;
if (this.writers.ContainsKey(associatedValueType))
{
valueWriter = this.writers[associatedValueType];
}
else
{
throw new ArgumentException(string.Format(
CultureInfo.InvariantCulture,
"Failed to find a value writer for your FieldInfo's AssociatedValueType (field={0}, valueType={1})",
fieldValueInfo.FieldInfo.InternalName,
associatedValueType.ToString()));
}
return(valueWriter);
}
/// <summary>
/// Writes a field value as an SPFolder's default column value
/// </summary>
/// <param name="folder">The folder for which we wish to update a field's default value</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (TaxonomyValueCollection)fieldValueInfo.Value;
var list = folder.ParentWeb.Lists[folder.ParentListId];
var taxonomyField = (TaxonomyField)list.Fields[fieldValueInfo.FieldInfo.Id];
MetadataDefaults listMetadataDefaults = new MetadataDefaults(list);
if (defaultValue != null)
{
var taxonomyFieldValueCollection = CreateSharePointTaxonomyFieldValue(taxonomyField, defaultValue, null);
string collectionValidatedString = taxonomyField.GetValidatedString(taxonomyFieldValueCollection);
listMetadataDefaults.SetFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName, collectionValidatedString);
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
/// <summary>
/// Writes a standard field value as an SPFolder's default value
/// </summary>
/// <param name="folder">The field for which we wish to update the default value</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (DateTime?)fieldValueInfo.Value;
var list = folder.ParentWeb.Lists[folder.ParentListId];
var listField = list.Fields[fieldValueInfo.FieldInfo.Id];
bool isPagesLibrary = (int)list.BaseTemplate == BuiltInListTemplates.Pages.ListTempateTypeId;
MetadataDefaults listMetadataDefaults = new MetadataDefaults(list);
// Pages library is a special case: attempting to set default value to TRUE will
// always fail because of patchy OOTB support.
if (isPagesLibrary &&
defaultValue.HasValue &&
(!string.IsNullOrEmpty(listField.DefaultValue) || !string.IsNullOrEmpty(listField.DefaultFormula)))
{
string exceptionMessage = "WriteValueToFolderDefault - Impossible to set folder default value as on DateTime-type field (fieldName={0})"
+ " within the Pages library when the SPField already has a DefaultValue or DefaultFormula. That folder column default (val={1})"
+ "would be ignored.";
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
exceptionMessage,
fieldValueInfo.FieldInfo.InternalName,
defaultValue.Value.ToString(CultureInfo.InvariantCulture)));
}
if (defaultValue.HasValue)
{
// Weirdness warning: don't forget to convert to UTC so that the list item default value gets applied in UTC
string dateString = FormatLocalDateTimeString(defaultValue.Value.ToUniversalTime());
listMetadataDefaults.SetFieldDefault(folder.ServerRelativeUrl, fieldValueInfo.FieldInfo.InternalName, dateString);
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder.ServerRelativeUrl, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
/// <summary>
/// Extracts the values from the entity to fill the values.
/// </summary>
/// <typeparam name="T">The type of the entity.</typeparam>
/// <param name="entity">The entity.</param>
/// <param name="listItem">The list item.</param>
public void FromEntity <T>(T entity, SPListItem listItem)
{
var schema = this.entitySchemaFactory.GetSchema(typeof(T));
var listItemFields = listItem.Fields;
foreach (var binding in schema.PropertyConversionDetails.ToList().Where(x => x.BindingType == BindingType.Bidirectional || x.BindingType == BindingType.WriteOnly))
{
var valueFromEntity = binding.EntityProperty.GetValue(entity, null);
IBaseValueWriter writer = binding.ValueWriter;
// Create a MinimalFieldInfo<TValueType> to feed into the FieldValueInfo needed to
// interact with IBaseValueWriter
var minimalFieldInfoType = typeof(MinimalFieldInfo <>).MakeGenericType(writer.AssociatedValueType);
string fieldInternalName = binding.ValueKey;
SPField itemField = listItemFields.GetFieldByInternalName(fieldInternalName);
var minimalFieldInfo = (BaseFieldInfo)Activator.CreateInstance(minimalFieldInfoType, new object[] { fieldInternalName, itemField.Id });
var fieldValueInfo = new FieldValueInfo(minimalFieldInfo, valueFromEntity);
// Update the list item through the IBaseValueWriter
writer.WriteValueToListItem(listItem, fieldValueInfo);
}
}
/// <summary>
/// Writes a field value as an SPFolder's default column value
/// </summary>
/// <param name="folder">The folder for which we wish to update a field's default value</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFolderDefault(SPFolder folder, FieldValueInfo fieldValueInfo)
{
var defaultValue = (ImageValue)fieldValueInfo.Value;
var list = folder.ParentWeb.Lists[folder.ParentListId];
MetadataDefaults listMetadataDefaults = new MetadataDefaults(folder.ParentWeb.Lists[folder.ParentListId]);
// Pages library is a special case: attempting to set default value will
// always fail because of patchy OOTB support.
if ((int)list.BaseTemplate == BuiltInListTemplates.Pages.ListTempateTypeId)
{
throw new NotSupportedException(
string.Format(
CultureInfo.InvariantCulture,
"WriteValueToFolderDefault - Initializing a folder column default value with ImageValue within the Pages library s not supported (fieldName={0}).",
fieldValueInfo.FieldInfo.InternalName));
}
if (defaultValue != null)
{
var sharePointFieldImageValue = CreateSharePointImageFieldValue(defaultValue);
this.log.Warn(
"WriteValueToFolderDefault - Initializing {0} field (fieldName={1}) with default value \"{2}\"."
+ " Be aware that folder default values on {0}-type field are not well supported by SharePoint and that this default"
+ " value will not be editable through your document library's \"List Settings > Column default value settings\" options page.",
fieldValueInfo.FieldInfo.FieldType,
fieldValueInfo.FieldInfo.InternalName,
sharePointFieldImageValue.ToString());
listMetadataDefaults.SetFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName, sharePointFieldImageValue.ToString());
}
else
{
listMetadataDefaults.RemoveFieldDefault(folder, fieldValueInfo.FieldInfo.InternalName);
}
listMetadataDefaults.Update();
}
/// <summary>
/// Writes a URL value as an SPField's default value
/// </summary>
/// <param name="parentFieldCollection">The parent field collection within which we can find the specific field to update</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFieldDefault(SPFieldCollection parentFieldCollection, FieldValueInfo fieldValueInfo)
{
var defaultValue = (UrlValue)fieldValueInfo.Value;
var field = parentFieldCollection[fieldValueInfo.FieldInfo.Id];
if (defaultValue != null)
{
var newUrlValue = new SPFieldUrlValue {
Url = defaultValue.Url, Description = defaultValue.Description
};
// Avoid setting the Description as well, otherwise all
// new items created with that field will have both the URL
// and Description in their URL and Description fields (weird lack
// of OOTB support for Url default values).
field.DefaultValue = newUrlValue.Url;
if (!string.IsNullOrEmpty(defaultValue.Description))
{
this.log.Warn(
"WriteValueToFieldDefault - Skipped initialization of Description property (val={0}) on Url field value (urlval={1})."
+ " A SPFieldUrlValue cannot support more than a simple URL string as default value for your field {2}."
+ " Be aware that field default values on \"Hyperlink or Picture\"-type field are not well supported by SharePoint"
+ " and that this default value will not be editable through your site column's settings page.",
defaultValue.Description,
defaultValue.Url,
fieldValueInfo.FieldInfo.InternalName);
}
else
{
this.log.Warn(
"WriteValueToFieldDefault - Be aware that field default values on \"Hyperlink or Picture\"-type field are not well supported by SharePoint"
+ " and that this default value will not be editable through your site column's settings page (fieldName={0}) defaultVal={1}).",
fieldValueInfo.FieldInfo.InternalName,
newUrlValue.Url);
}
}
else
{
field.DefaultValue = null;
}
}
/// <summary>
/// Writes a Lookup value as an SPField's default value
/// WARNING: This should only be used in scenarios where you have complete and exclusive programmatic
/// access to item creation - because SharePoint has patchy support for this and your NewForm.aspx pages WILL break.
/// </summary>
/// <param name="parentFieldCollection">The parent field collection within which we can find the specific field to update</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFieldDefault(SPFieldCollection parentFieldCollection, FieldValueInfo fieldValueInfo)
{
var defaultValue = (LookupValue)fieldValueInfo.Value;
var field = parentFieldCollection[fieldValueInfo.FieldInfo.Id];
if (defaultValue != null)
{
field.DefaultValue = new SPFieldLookupValue(defaultValue.Id, defaultValue.Value).ToString();
this.log.Warn(
"Default value ({0}) set on field {1} with type Lookup. SharePoint does not support default values on Lookup fields through its UI."
+ " Only list items created programmatically will get the default value properly set. Setting a Lookup-field default value"
+ " will not be respected by your lists' NewForm.aspx item creation form.",
field.DefaultValue,
field.InternalName);
}
else
{
field.DefaultValue = null;
}
}
/// <summary>
/// Writes a lookup field value to a SPListItem
/// </summary>
/// <param name="item">The SharePoint List Item</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToListItem(SPListItem item, FieldValueInfo fieldValueInfo)
{
var lookup = fieldValueInfo.Value as LookupValue;
item[fieldValueInfo.FieldInfo.InternalName] = lookup != null ? new SPFieldLookupValue(lookup.Id, lookup.Value) : null;
}
/// <summary>
/// Updates the specified SPField definition with new DefaultValue
/// </summary>
/// <param name="parentFieldCollection">The SharePoint field collection containing the field to update.</param>
/// <param name="defaultFieldValueInfo">The default value to be applied as the SPField' new default.</param>
public void WriteValueToFieldDefault(SPFieldCollection parentFieldCollection, FieldValueInfo defaultFieldValueInfo)
{
if (parentFieldCollection == null)
{
throw new ArgumentNullException("parentFieldCollection");
}
if (defaultFieldValueInfo == null || defaultFieldValueInfo.FieldInfo == null)
{
throw new ArgumentNullException("defaultFieldValueInfo");
}
IBaseValueWriter valueWriter = this.GetWriter(defaultFieldValueInfo);
valueWriter.WriteValueToFieldDefault(parentFieldCollection, defaultFieldValueInfo);
}
/// <summary>
/// Writes a Taxonomy single value as an SPField's default value
/// </summary>
/// <param name="parentFieldCollection">The parent field collection within which we can find the specific field to update</param>
/// <param name="fieldValueInfo">The field and value information</param>
public override void WriteValueToFieldDefault(SPFieldCollection parentFieldCollection, FieldValueInfo fieldValueInfo)
{
var defaultValue = (TaxonomyValue)fieldValueInfo.Value;
var taxonomyField = (TaxonomyField)parentFieldCollection[fieldValueInfo.FieldInfo.Id];
if (defaultValue != null)
{
taxonomyField.DefaultValue = FormatTaxonomyString(taxonomyField, defaultValue);
}
else
{
taxonomyField.DefaultValue = null;
}
taxonomyField.Update();
}