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(); }