public override void ExtractingProperty(Item item, ContentProperty propertyData) { if (propertyData.Value != null) { var links = JsonConvert.DeserializeObject <JArray>(propertyData.Value.ToString()); if (links != null) { foreach (var link in links) { var isMedia = link["isMedia"] != null || link["udi"] != null && link["udi"].ToString().StartsWith("umb://media"); if (link["id"] == null) { continue; } var nodeObjectType = isMedia ? UmbracoNodeObjectTypeIds.Media : UmbracoNodeObjectTypeIds.Document; Guid nodeGuid; if (Guid.TryParse(link["id"].ToString(), out nodeGuid)) { link["id"] = ExecutionContext.DatabasePersistence.GetNodeId(nodeGuid, nodeObjectType); } } propertyData.Value = links; } } }
public int Save(ContentBinding Model) { using (var _c = db) { var _Model = new ContentProperty(); if (Model.ContentPropertyID == 0) { var _IQParent = _c.ContentProperties.Where(m => m.SiteID == Model.SiteID && m.ContentPropertyParentID == Model.ContentPropertyParentID); _Model.ContentPropertyParentID = Model.ContentPropertyParentID; _Model.SiteID = Model.SiteID; _Model.Priority = _IQParent.Any() ? _IQParent.Select(m => m.Priority).Max() + 1 : 0; _Model.Lock = Model.Lock; _Model.Enabled = true; _c.ContentProperties.Add(_Model); } else { _Model = _c.ContentProperties.Where(m => m.ContentPropertyID == Model.ContentPropertyID).SingleOrDefault(); _Model.Priority = Model.Priority; } _Model.ContentPropertyAlias = Model.ContentPropertyAlias; _Model.ContentPropertyType = Model.ContentPropertyType; _c.SaveChanges(); //SAVE ROOT AddRoot(_Model.ContentPropertyID, _Model.ContentPropertyParentID); return(_Model.ContentPropertyID); } }
public override void PackagingProperty(Item item, ContentProperty propertyData) { if (item != null) { item.Dependencies.Add(item.ItemId.Id, ProviderIDCollection.tagRelationsProviderGuid); } }
static CustomContentControl() { ContentProperty.OverrideMetadata( typeof(CustomContentControl), new FrameworkPropertyMetadata(new PropertyChangedCallback(OnContentChanged)) ); }
static LayoutFloatingWindowControl() { AllowsTransparencyProperty.OverrideMetadata(typeof(LayoutFloatingWindowControl), new FrameworkPropertyMetadata(false)); ContentProperty.OverrideMetadata(typeof(LayoutFloatingWindowControl), new FrameworkPropertyMetadata(null, null, CoerceContentValue)); ShowInTaskbarProperty.OverrideMetadata(typeof(LayoutFloatingWindowControl), new FrameworkPropertyMetadata(false)); WindowStyleProperty.OverrideMetadata(typeof(LayoutFloatingWindowControl), new FrameworkPropertyMetadata(WindowStyle.None)); }
public static ContentPropertyResponse CreateContentlessDocumentLinkToFolder(string repo, string folderId) { DocumentumServiceUtils.ConfigureApiClient(repo); ContentProperty contentProperty = new ContentProperty(); contentProperty.properties = new PropertiesType(); contentProperty.properties.r_object_type = "dwr_gen_doc"; contentProperty.properties.object_name = "readme6"; contentProperty.properties.author_creator = "Pedro Barroso"; contentProperty.properties.author_date = "2017-09-26"; contentProperty.properties.topic_subject = "The subject"; IDocumentumApi documentumApi = new DocumentumApi(); ContentPropertyResponse response = null; try { response = documentumApi.CreateContentlessDocument(repo, folderId, contentProperty); } catch (ApiException ex) { Log.Error(ex); } return(response); }
static RangeBase3D() { ContentProperty.OverrideMetadata( typeof(RangeBase3D), new UIPropertyMetadata( ContentPropertyChanged)); }
public void SetsOrderFieldAndAscendingDirection(ContentProperty field) { var sut = new ContentCriteria().OrderBy(field); Assert.AreEqual(EkEnumeration.OrderByDirection.Ascending, sut.OrderByDirection); Assert.AreEqual(field, sut.OrderByField); }
void Attach() { _verticalScrollBarVisibilityProperty.Attach(OnScrollBarVisibilityChanged); _horizontalScrollBarVisibilityProperty.Attach(OnScrollBarVisibilityChanged); ContentProperty.Attach(OnContentChanged); }
/// <summary> /// Get the dependency property tests. /// </summary> /// <returns>The dependency property tests.</returns> public override IEnumerable <DependencyPropertyTestMethod> GetDependencyPropertyTests() { // Get the base Control dependency property tests IList <DependencyPropertyTestMethod> tests = TagInherited(base.GetDependencyPropertyTests()); // ContentProperty tests tests.Add(ContentProperty.CheckDefaultValueTest); tests.Add(ContentProperty.ChangeClrSetterTest); tests.Add(ContentProperty.ChangeSetValueTest); tests.Add(ContentProperty.SetNullTest); tests.Add(ContentProperty.ClearValueResetsDefaultTest); tests.Add(ContentProperty.CanBeStyledTest); tests.Add(ContentProperty.TemplateBindTest); tests.Add(ContentProperty.DoesNotChangeVisualStateTest(null, "Test")); tests.Add(ContentProperty.SetXamlAttributeTest); tests.Add(ContentProperty.SetXamlElementTest); tests.Add(ContentProperty.SetXamlContentTest); tests.Add(ContentProperty.IsContentPropertyTest); tests.Add(ContentProperty.DataTemplateWithIntTest); tests.Add(ContentProperty.DataTemplateWithStringTest); tests.Add(ContentProperty.DataTemplateWithStringAndPropertyTest); tests.Add(ContentProperty.DataTemplateWithUIElementFailsTest); tests.Add(ContentProperty.DataTemplateWithBusinessObjectTest); // ContentTemplateProperty tests tests.Add(ContentTemplateProperty.CheckDefaultValueTest); tests.Add(ContentTemplateProperty.ChangeClrSetterTest); tests.Add(ContentTemplateProperty.ChangeSetValueTest); tests.Add(ContentTemplateProperty.SetNullTest); tests.Add(ContentTemplateProperty.ClearValueResetsDefaultTest); tests.Add(ContentTemplateProperty.CanBeStyledTest); tests.Add(ContentTemplateProperty.TemplateBindTest); return(tests); }
static StyleDialog() { DefaultStyleKeyProperty.OverrideMetadata(typeof(StyleDialog), new FrameworkPropertyMetadata(typeof(StyleDialog))); ContentProperty.OverrideMetadata(typeof(StyleDialog), new FrameworkPropertyMetadata(new PropertyChangedCallback(Changed))); WidthProperty.OverrideMetadata(typeof(StyleDialog), new FrameworkPropertyMetadata(new PropertyChangedCallback(Changed))); HeightProperty.OverrideMetadata(typeof(StyleDialog), new FrameworkPropertyMetadata(new PropertyChangedCallback(Changed))); }
/// <summary> /// Get the dependency property tests. /// </summary> /// <returns>The dependency property tests.</returns> public override IEnumerable <DependencyPropertyTestMethod> GetDependencyPropertyTests() { List <DependencyPropertyTestMethod> tests = new List <DependencyPropertyTestMethod>(base.GetDependencyPropertyTests()); tests.RemoveTests(ContentProperty.DoesNotChangeVisualStateTest(null, "Test")); return(tests); }
public override void ExtractingProperty(Core.Item item, ContentProperty propertyData) { propertyData.Value = XmlDependencies.ReplaceIds( propertyData.Value.ToString(), dataXpath, IdentifierReplaceDirection.FromGuidToNodeId); }
public int Save(ContentBindingList Model) { using (var _c = db) { var _CP = new ContentProperty { ContentPropertyParentID = Model.ContentPropertyParentID, SiteID = Model.SiteID, ContentPropertyType = Model.ContentPropertyType, ContentPropertyAlias = Model.ContentPropertyAlias, Priority = Model.Priority, Lock = Model.Lock, ShowInContent = Model.ShowInContent, Enabled = true }; _c.ContentProperties.Add(_CP); _c.SaveChanges(); //SAVE ROOT AddRoot(_CP.ContentPropertyID, _CP.ContentPropertyParentID); var _NumCultureSite = _c.Cultures.Where(m => m.SiteID == Model.SiteID).Count(); if (_NumCultureSite < Model.ContentCultures.Count()) { throw new RuleException(ContentRuleExceptionCode.MORECULTURES.ToString(), "Content Alias:" + Model.ContentPropertyAlias + " with " + Model.ContentCultures.Count() + " and Site have " + _NumCultureSite + " Cultures"); } foreach (var item in Model.ContentCultures) { item.ContentPropertyID = _CP.ContentPropertyID; SaveCulture(item, Model.SiteID); } return(_CP.ContentPropertyID); } }
/// <summary> /// Returns a collection of properties for the type of array specified by the value parameter, using the specified context and attributes. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context.</param> /// <param name="value">An <see cref="T:System.Object" /> that specifies the type of array for which to get properties.</param> /// <param name="attributes">An array of type <see cref="T:System.Attribute" /> that is used as a filter.</param> /// <returns> /// A <see cref="T:System.ComponentModel.PropertyDescriptorCollection" /> with the properties that are exposed for this data type, or null if there are no properties. /// </returns> public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes) { var typeDesc = (ContentTypeDescriptor)context.Instance; var content = typeDesc.Content; PropertyDescriptorCollection result = TypeDescriptor.GetProperties(value, attributes); var properties = new List <ContentPropertyDescriptor>(); // Build the property descriptors for the blending type. foreach (PropertyDescriptor descriptor in result.Cast <PropertyDescriptor>().Where(item => !_depthProps.Contains(item.Name))) { var contentProp = new ContentProperty(descriptor, value, content.TypeDescriptor["Stencil"]) { HasDefaultValue = true, RefreshProperties = RefreshProperties.All, IsReadOnly = false }; if (string.Equals(descriptor.Name, "FrontFace", StringComparison.OrdinalIgnoreCase)) { contentProp.IsReadOnly = true; contentProp.Converter = typeof(StencilStateTypeConverter).AssemblyQualifiedName; contentProp.DisplayName = APIResources.PROP_STENCIL_FRONT_NAME; contentProp.Description = APIResources.PROP_STENCIL_FRONT_DESC; } if (string.Equals(descriptor.Name, "BackFace", StringComparison.OrdinalIgnoreCase)) { contentProp.IsReadOnly = true; contentProp.Converter = typeof(StencilStateTypeConverter).AssemblyQualifiedName; contentProp.DisplayName = APIResources.PROP_STENCIL_BACK_NAME; contentProp.Description = APIResources.PROP_STENCIL_BACK_DESC; } if (string.Equals(descriptor.Name, "StencilReference", StringComparison.OrdinalIgnoreCase)) { contentProp.DisplayName = APIResources.PROP_STENCIL_REFERENCE_NAME; contentProp.Description = APIResources.PROP_STENCIL_REFERENCE_DESC; contentProp.DefaultValue = 0; } if (string.Equals(descriptor.Name, "StencilReadMask", StringComparison.OrdinalIgnoreCase)) { contentProp.DisplayName = APIResources.PROP_STENCIL_READ_MASK_NAME; contentProp.Description = APIResources.PROP_STENCIL_READ_MASK_DESC; contentProp.DefaultValue = 255; } if (string.Equals(descriptor.Name, "StencilWriteMask", StringComparison.OrdinalIgnoreCase)) { contentProp.DisplayName = APIResources.PROP_STENCIL_WRITE_MASK_NAME; contentProp.Description = APIResources.PROP_STENCIL_WRITE_MASK_DESC; contentProp.DefaultValue = 255; } properties.Add(new ContentPropertyDescriptor(contentProp)); } return(new PropertyDescriptorCollection(properties.Cast <PropertyDescriptor>().OrderBy(item => item.DisplayName ?? item.Name).ToArray())); }
protected void AttendButton_Click(object sender, EventArgs e) { IParticipant participant; if (!string.IsNullOrEmpty(HiddenEmail.Value)) { participant = AttendRegistrationEngine.GetParticipant(HiddenEmail.Value, HiddenCode.Value); if (participant != null) { participant = (participant as ParticipantBlock).CreateWritableClone() as ParticipantBlock; } } else { string participantEmail = ""; foreach (var fragment in DetailsXFormControl.ExtractXFormControls()) { if (fragment.ID == "epost" || fragment.ID == "email") { participantEmail = fragment.Value; } } if (string.IsNullOrEmpty(participantEmail) || Business.Email.Validation.IsEmail(participantEmail) == false) { return; } participant = AttendRegistrationEngine.GenerateParticipation(CurrentData.ContentLink, participantEmail, true, DetailsXFormControl.Data.Data.OuterXml, "Participant submitted form"); } if (participant != null) { participant.XForm = DetailsXFormControl.Data.Data.OuterXml; participant.Sessions = new ContentArea(); foreach (ContentReference item in GetChosenSessions()) { participant.Sessions.Items.Add(new ContentAreaItem() { ContentLink = item }); } Locate.ContentRepository().Save(participant as IContent, EPiServer.DataAccess.SaveAction.Publish, EPiServer.Security.AccessLevel.NoAccess); string propertyName = ""; if (participant.AttendStatus == AttendStatus.Confirmed.ToString()) { propertyName = "CompleteContent"; } if (participant.AttendStatus == AttendStatus.Submitted.ToString()) { propertyName = "SubmittedContent"; } ContentProperty.PropertyName = propertyName; ContentProperty.DataBind(); DetailsXFormControl.Visible = false; AttendButton.Visible = false; } }
static MediaPlayer() { DefaultStyleKeyProperty.OverrideMetadata(typeof(MediaPlayer), new FrameworkPropertyMetadata(typeof(MediaPlayer))); BackgroundProperty.OverrideMetadata(typeof(MediaPlayer), new FrameworkPropertyMetadata(Brushes.Black)); HorizontalAlignmentProperty.OverrideMetadata(typeof(MediaPlayer), new FrameworkPropertyMetadata(HorizontalAlignment.Stretch)); VerticalAlignmentProperty.OverrideMetadata(typeof(MediaPlayer), new FrameworkPropertyMetadata(VerticalAlignment.Stretch)); ContentProperty.OverrideMetadata(typeof(MediaPlayer), new FrameworkPropertyMetadata(ContentChanged, CoerceContent)); }
static MyLabel() { ContentProperty.OverrideMetadata(typeof(MyLabel), new FrameworkPropertyMetadata( new PropertyChangedCallback(OnContentChanged))); }
static TransitionControl() { DefaultStyleKeyProperty.OverrideMetadata( typeof(TransitionControl), new FrameworkPropertyMetadata(typeof(TransitionControl))); ContentProperty.OverrideMetadata( typeof(TransitionControl), new FrameworkPropertyMetadata(OnContentPropertyChanged)); }
public override void PackagingProperty(Item item, ContentProperty propertyData) { Guid g; if (propertyData.Value != null && Guid.TryParse(propertyData.Value.ToString(), out g)) { item.Dependencies.Add(g.ToString(), Constants.ProviderId); } }
/// <summary> /// Initializes static members of the <see cref="MathBlock" /> class. /// </summary> static MathBlock() { DefaultStyleKeyProperty.OverrideMetadata( typeof(MathBlock), new FrameworkPropertyMetadata(typeof(MathBlock))); ContentProperty.OverrideMetadata( typeof(MathBlock), new FrameworkPropertyMetadata(typeof(MathBlock), (s, e) => ((MathBlock)s).ContentChanged())); }
public static ContentPropertyDto ToDto(this ContentProperty property) { return(new ContentPropertyDto { IsRequired = property.IsRequired, Key = property.Key, Value = property.Value.ToDto() }); }
/// <summary> /// Returns a collection of properties for the type of array specified by the value parameter, using the specified context and attributes. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context.</param> /// <param name="value">An <see cref="T:System.Object" /> that specifies the type of array for which to get properties.</param> /// <param name="attributes">An array of type <see cref="T:System.Attribute" /> that is used as a filter.</param> /// <returns> /// A <see cref="T:System.ComponentModel.PropertyDescriptorCollection" /> with the properties that are exposed for this data type, or null if there are no properties. /// </returns> public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes) { var typeDesc = (ContentTypeDescriptor)context.Instance; PropertyDescriptorCollection result = TypeDescriptor.GetProperties(value, attributes); var properties = new List <ContentPropertyDescriptor>(); // Build the property descriptors for the blending type. foreach (PropertyDescriptor descriptor in result) { var contentProp = new ContentProperty(descriptor, value, typeDesc["TextureSampler"]) { HasDefaultValue = true, RefreshProperties = RefreshProperties.All, IsReadOnly = typeDesc["TextureSampler"].IsReadOnly }; if (string.Equals(descriptor.Name, "TextureFilter", StringComparison.OrdinalIgnoreCase)) { contentProp.DefaultValue = TextureFilter.Point; contentProp.Converter = typeof(TextureFilterTypeConverter).AssemblyQualifiedName; contentProp.DisplayName = APIResources.PROP_SAMPLE_FILTER_NAME; contentProp.Description = APIResources.PROP_SAMPLE_FILTER_DESC; } if (string.Equals(descriptor.Name, "HorizontalWrapping", StringComparison.OrdinalIgnoreCase)) { contentProp.RefreshProperties = RefreshProperties.All; contentProp.DefaultValue = TextureAddressing.Clamp; contentProp.Converter = typeof(TextureAddressingTypeConverter).AssemblyQualifiedName; contentProp.DisplayName = APIResources.PROP_SAMPLE_HORZADDR_NAME; contentProp.Description = APIResources.PROP_SAMPLE_HORZADDR_DESC; } if (string.Equals(descriptor.Name, "VerticalWrapping", StringComparison.OrdinalIgnoreCase)) { contentProp.RefreshProperties = RefreshProperties.All; contentProp.DefaultValue = TextureAddressing.Clamp; contentProp.Converter = typeof(TextureAddressingTypeConverter).AssemblyQualifiedName; contentProp.DisplayName = APIResources.PROP_SAMPLE_VERTADDR_NAME; contentProp.Description = APIResources.PROP_SAMPLE_VERTADDR_DESC; } if (string.Equals(descriptor.Name, "BorderColor", StringComparison.OrdinalIgnoreCase)) { contentProp.DefaultValue = GorgonColor.Transparent; contentProp.Converter = typeof(RGBATypeConverter).AssemblyQualifiedName; contentProp.SetTypeEditor(typeof(RGBAEditor), typeof(UITypeEditor)); contentProp.DisplayName = APIResources.PROP_SAMPLE_BORDER_NAME; contentProp.Description = APIResources.PROP_SAMPLE_BORDER_DESC; } properties.Add(new ContentPropertyDescriptor(contentProp)); } return(new PropertyDescriptorCollection(properties.Cast <PropertyDescriptor>().OrderBy(item => item.DisplayName ?? item.Name).ToArray())); }
static FormattedTextBlock() { DefaultStyleKeyProperty.OverrideMetadata( typeof(FormattedTextBlock), new FrameworkPropertyMetadata(typeof(FormattedTextBlock))); ContentProperty.OverrideMetadata( typeof(FormattedTextBlock), new PropertyMetadata(defaultValue: null, ContentPropertyChangedHandler)); }
static DocumentFloatingWindow() { //This OverrideMetadata call tells the system that this element wants to provide a style that is different than its base class. //This style is defined in themes\generic.xaml DefaultStyleKeyProperty.OverrideMetadata(typeof(DocumentFloatingWindow), new FrameworkPropertyMetadata(typeof(DocumentFloatingWindow))); ContentProperty.OverrideMetadata(typeof(DocumentFloatingWindow), new FrameworkPropertyMetadata( new PropertyChangedCallback(OnContentPropertyChanged), new CoerceValueCallback(OnCoerceValueContentProperty))); }
/// <summary> /// Initializes static members of the RibbonGalleryItem class. /// </summary> static RibbonGalleryItem() { Type ownerType = typeof(RibbonGalleryItem); DefaultStyleKeyProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata(ownerType)); ContentProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata(null, new PropertyChangedCallback(OnContentChanged), new CoerceValueCallback(CoerceContent))); ToolTipProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata(null, new CoerceValueCallback(RibbonHelper.CoerceRibbonToolTip))); ToolTipService.ShowOnDisabledProperty.OverrideMetadata(ownerType, new FrameworkPropertyMetadata(true)); EventManager.RegisterClassHandler(ownerType, KeyTipService.ActivatingKeyTipEvent, new ActivatingKeyTipEventHandler(OnActivatingKeyTipThunk)); EventManager.RegisterClassHandler(ownerType, KeyTipService.KeyTipAccessedEvent, new KeyTipAccessedEventHandler(OnKeyTipAccessedThunk)); }
/// <summary> /// Returns a collection of properties for the type of array specified by the value parameter, using the specified context and attributes. /// </summary> /// <param name="context">An <see cref="T:System.ComponentModel.ITypeDescriptorContext" /> that provides a format context.</param> /// <param name="value">An <see cref="T:System.Object" /> that specifies the type of array for which to get properties.</param> /// <param name="attributes">An array of type <see cref="T:System.Attribute" /> that is used as a filter.</param> /// <returns> /// A <see cref="T:System.ComponentModel.PropertyDescriptorCollection" /> with the properties that are exposed for this data type, or null if there are no properties. /// </returns> public override PropertyDescriptorCollection GetProperties(ITypeDescriptorContext context, object value, Attribute[] attributes) { PropertyDescriptorCollection result = TypeDescriptor.GetProperties(value, attributes); var properties = new List <ContentPropertyDescriptor>(); Debug.Assert(context.PropertyDescriptor != null, "Property descriptor is NULL"); // Build the property descriptors for the blending type. foreach (PropertyDescriptor descriptor in result) { var contentProp = new ContentProperty(descriptor, value, ((ContentPropertyDescriptor)context.PropertyDescriptor).ContentProperty) { HasDefaultValue = true, RefreshProperties = RefreshProperties.All, IsReadOnly = false }; if (string.Equals(descriptor.Name, "ComparisonOperator", StringComparison.OrdinalIgnoreCase)) { contentProp.Converter = typeof(ComparisonTypeConverter).AssemblyQualifiedName; contentProp.DefaultValue = ComparisonOperator.Always; contentProp.DisplayName = APIResources.PROP_STENCIL_OP_COMPARE_NAME; contentProp.Description = APIResources.PROP_STENCIL_OP_COMPARE_DESC; } if (string.Equals(descriptor.Name, "PassOperation", StringComparison.OrdinalIgnoreCase)) { contentProp.Converter = typeof(StencilOperationsTypeConverter).AssemblyQualifiedName; contentProp.DefaultValue = StencilOperation.Keep; contentProp.DisplayName = APIResources.PROP_STENCIL_OP_PASS_NAME; contentProp.Description = APIResources.PROP_STENCIL_OP_PASS_DESC; } if (string.Equals(descriptor.Name, "FailOperation", StringComparison.OrdinalIgnoreCase)) { contentProp.Converter = typeof(StencilOperationsTypeConverter).AssemblyQualifiedName; contentProp.DefaultValue = StencilOperation.Keep; contentProp.DisplayName = APIResources.PROP_STENCIL_OP_FAIL_NAME; contentProp.Description = APIResources.PROP_STENCIL_OP_FAIL_DESC; } if (string.Equals(descriptor.Name, "DepthFailOperation", StringComparison.OrdinalIgnoreCase)) { contentProp.Converter = typeof(StencilOperationsTypeConverter).AssemblyQualifiedName; contentProp.DefaultValue = StencilOperation.Keep; contentProp.DisplayName = APIResources.PROP_STENCIL_OP_DEPTH_FAIL_NAME; contentProp.Description = APIResources.PROP_STENCIL_OP_DEPTH_FAIL_DESC; } properties.Add(new ContentPropertyDescriptor(contentProp)); } return(new PropertyDescriptorCollection(properties.Cast <PropertyDescriptor>().OrderBy(item => item.DisplayName ?? item.Name).ToArray())); }
//------------------------------------------------------ // // Constructors // //------------------------------------------------------ #region Constructors /// <summary> /// Constructs a window object /// </summary> static NavigationWindow() { _dType = DependencyObjectType.FromSystemTypeInternal(typeof(NavigationWindow)); DefaultStyleKeyProperty.OverrideMetadata( typeof(NavigationWindow), new FrameworkPropertyMetadata(typeof(NavigationWindow))); ContentProperty.OverrideMetadata( typeof(NavigationWindow), new FrameworkPropertyMetadata( null, new CoerceValueCallback(CoerceContent))); SandboxExternalContentProperty.OverrideMetadata( typeof(NavigationWindow), new FrameworkPropertyMetadata(new PropertyChangedCallback(OnSandboxExternalContentPropertyChanged), new CoerceValueCallback(CoerceSandBoxExternalContentValue))); CommandManager.RegisterClassCommandBinding( typeof(NavigationWindow), new CommandBinding( NavigationCommands.BrowseBack, new ExecutedRoutedEventHandler(OnGoBack), new CanExecuteRoutedEventHandler(OnQueryGoBack))); CommandManager.RegisterClassCommandBinding( typeof(NavigationWindow), new CommandBinding( NavigationCommands.BrowseForward, new ExecutedRoutedEventHandler(OnGoForward), new CanExecuteRoutedEventHandler(OnQueryGoForward))); CommandManager.RegisterClassCommandBinding( typeof(NavigationWindow), new CommandBinding(NavigationCommands.NavigateJournal, new ExecutedRoutedEventHandler(OnNavigateJournal))); CommandManager.RegisterClassCommandBinding( typeof(NavigationWindow), new CommandBinding( NavigationCommands.Refresh, new ExecutedRoutedEventHandler(OnRefresh), new CanExecuteRoutedEventHandler(OnQueryRefresh))); CommandManager.RegisterClassCommandBinding( typeof(NavigationWindow), new CommandBinding( NavigationCommands.BrowseStop, new ExecutedRoutedEventHandler(OnBrowseStop), new CanExecuteRoutedEventHandler(OnQueryBrowseStop))); }
static DataGridRowHeader() { DefaultStyleKeyProperty.OverrideMetadata(typeof(DataGridRowHeader), new FrameworkPropertyMetadata(typeof(DataGridRowHeader))); ContentProperty.OverrideMetadata(typeof(DataGridRowHeader), new FrameworkPropertyMetadata(OnNotifyPropertyChanged, OnCoerceContent)); ContentTemplateProperty.OverrideMetadata(typeof(DataGridRowHeader), new FrameworkPropertyMetadata(OnNotifyPropertyChanged, OnCoerceContentTemplate)); ContentTemplateSelectorProperty.OverrideMetadata(typeof(DataGridRowHeader), new FrameworkPropertyMetadata(OnNotifyPropertyChanged, OnCoerceContentTemplateSelector)); StyleProperty.OverrideMetadata(typeof(DataGridRowHeader), new FrameworkPropertyMetadata(OnNotifyPropertyChanged, OnCoerceStyle)); WidthProperty.OverrideMetadata(typeof(DataGridRowHeader), new FrameworkPropertyMetadata(OnNotifyPropertyChanged, OnCoerceWidth)); ClickModeProperty.OverrideMetadata(typeof(DataGridRowHeader), new FrameworkPropertyMetadata(ClickMode.Press)); FocusableProperty.OverrideMetadata(typeof(DataGridRowHeader), new FrameworkPropertyMetadata(false)); }
/// <summary> /// Initializes static members of the <see cref="MediaElement"/> class. /// </summary> static MediaElement() { // Content property cannot be changed. ContentProperty.OverrideMetadata(typeof(MediaElement), new FrameworkPropertyMetadata(null, OnCoerceContentValue)); var style = new Style(typeof(MediaElement), null); style.Setters.Add(new Setter(FlowDirectionProperty, FlowDirection.LeftToRight)); style.Seal(); StyleProperty.OverrideMetadata(typeof(MediaElement), new FrameworkPropertyMetadata(style)); // Initialize the core MediaEngine.Initialize(WindowsPlatform.Instance); }
/// <summary> /// Replaces the property data Ids. /// </summary> /// <param name="item">The item.</param> /// <param name="propertyData">The property data.</param> /// <param name="direction">The direction.</param> private void ReplacePropertyDataIds(Item item, ContentProperty propertyData, Direction direction) { if (propertyData != null && propertyData.Value != null) { var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(new ItemIdentifier(propertyData.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid)); //Deserialize the value of the current Property to an ArchetypeModel and set additional properties before converting values var sourceJson = propertyData.Value.ToString(); var canvas = JsonConvert.DeserializeObject<CanvasModel>(sourceJson); // serialize the Archetype back to a string propertyData.Value = JsonConvert.SerializeObject(canvas, Formatting.None); } }
public override void ExtractingProperty(Item item, ContentProperty propertyData) { if (propertyData.Value != null) { var links = JsonConvert.DeserializeObject<JArray>(propertyData.Value.ToString()); if (links != null) { foreach (dynamic link in links) { if (link.id != null) { link.id = ExecutionContext.DatabasePersistence.GetNodeId( (Guid)link.id, link.isMedia != null ? UmbracoNodeObjectTypeIds.Media : UmbracoNodeObjectTypeIds.Document); } } propertyData.Value = links; } } }
public override void PackagingProperty(Item item, ContentProperty propertyData) { if (propertyData.Value != null) { var links = JsonConvert.DeserializeObject<JArray>(propertyData.Value.ToString()); if (links != null) { foreach (dynamic link in links) { if (link.id != null) { link.id = ExecutionContext.DatabasePersistence.GetUniqueId( (int)link.id, link.isMedia != null ? NodeObjectTypes.Media : NodeObjectTypes.Document); } } propertyData.Value = links.ToString(); } } }
public override void ExtractingProperty(Item item, ContentProperty propertyData) { if (propertyData.Value != null) { var links = JsonConvert.DeserializeObject<JArray>(propertyData.Value.ToString()); if (links != null) { foreach (dynamic link in links) { if (link.id != null) { link.id = PersistenceManager.Default.GetNodeId( (Guid)link.id, link.isMedia != null ? NodeObjectTypes.Media : NodeObjectTypes.Document); } } propertyData.Value = links.ToString(); } } }
public override void PackagingProperty(Item item, ContentProperty propertyData) { if (propertyData.Value != null) { var links = JsonConvert.DeserializeObject<JArray>(propertyData.Value.ToString()); if (links != null) { foreach (dynamic link in links) { if (link.id != null) { var objectTypeId = link.isMedia != null ? UmbracoNodeObjectTypeIds.Media : UmbracoNodeObjectTypeIds.Document; var itemProviderId = link.isMedia != null ? ItemProviderIds.mediaItemProviderGuid : ItemProviderIds.documentItemProviderGuid; link.id = ExecutionContext.DatabasePersistence.GetUniqueId((int)link.id, objectTypeId); item.Dependencies.Add(link.id.ToString(), itemProviderId); } else if (link.isMedia != null) { try { var mediaId = ExecutionContext.DatabasePersistence.GetUniqueIdFromMediaFile(link.url); item.Dependencies.Add(mediaId.ToString(), ItemProviderIds.mediaItemProviderGuid); } catch (Exception e) { CourierLogHelper.Error<MultiUrlPickerDataResolverProvider>(string.Format("Error setting media-item dependency, name={0}, url={1}", link.name, link.url), e); } } } propertyData.Value = links.ToString(); } } }
public override void ExtractingCell(Item item, ContentProperty propertyData, dynamic cell) { ProcessCell(item, propertyData, cell, Direction.Extracting); }
private void ResolvePropertyData(Item item, ContentProperty propertyData, Direction direction) { if (propertyData == null || propertyData.Value == null) return; // create a fake `PublishedPropertyType` var dataTypeId = ExecutionContext.DatabasePersistence.GetNodeId(propertyData.DataType, UmbracoNodeObjectTypeIds.DataType); // deserialize the current Property's value into a 'MortarValue' var mortarValue = JsonConvert.DeserializeObject<MortarValue>(propertyData.Value.ToString()); // get the `PropertyItemProvider` from the collection. var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ItemProviderIds.propertyDataItemProviderGuid, this.ExecutionContext); if (mortarValue != null) { foreach (var mortarBlock in mortarValue) { foreach (var mortarRow in mortarBlock.Value) { var rowOptionsDocTypeAlias = MortarHelper.GetRowOptionsDocType(dataTypeId, mortarBlock.Key); if (!string.IsNullOrWhiteSpace(rowOptionsDocTypeAlias)) { mortarRow.RawOptions = ResolveMultiplePropertyItemData(item, propertyItemProvider, mortarRow.RawOptions, rowOptionsDocTypeAlias, direction); } foreach (var mortarItem in mortarRow.Items) { if (mortarItem == null) { CourierLogHelper.Warn<MortarDataResolver>("MortarItem appears to be null, (from '{0}' block)", () => mortarBlock.Key); continue; } if (mortarItem.Type == null) { CourierLogHelper.Warn<MortarDataResolver>("MortarItem did not contain a value for Type, (from '{0}' block)", () => mortarBlock.Key); continue; } switch (mortarItem.Type.ToUpperInvariant()) { case "DOCTYPE": // resolve the doctype alias/guid string docTypeAlias = string.Empty; if (mortarItem.AdditionalInfo.ContainsKey("docType")) { docTypeAlias = mortarItem.AdditionalInfo["docType"]; DocumentType docType; Guid docTypeGuid; if (Guid.TryParse(docTypeAlias, out docTypeGuid)) { docType = ExecutionContext.DatabasePersistence.RetrieveItem<DocumentType>( new ItemIdentifier(docTypeGuid.ToString(), ItemProviderIds.documentTypeItemProviderGuid)); docTypeAlias = docType.Alias; } else { docType = ExecutionContext.DatabasePersistence.RetrieveItem<DocumentType>( new ItemIdentifier(docTypeAlias, ItemProviderIds.documentTypeItemProviderGuid)); docTypeGuid = docType.UniqueId; } if (direction == Direction.Packaging) { mortarItem.AdditionalInfo["docType"] = docTypeAlias; // add dependency for the DocType var name = string.Concat("Document type: ", docTypeAlias); var dependency = new Dependency(name, docTypeAlias, ItemProviderIds.documentTypeItemProviderGuid); item.Dependencies.Add(dependency); } else if (direction == Direction.Extracting) { // NOTE: [LK] In v0.4.0 we swapped the usage from the DocType's GUID back to the alias. mortarItem.AdditionalInfo["docType"] = docTypeAlias; // docTypeGuid.ToString(); } } // resolve the value's properties mortarItem.RawValue = ResolveMultiplePropertyItemData(item, propertyItemProvider, mortarItem.RawValue, docTypeAlias, direction); break; case "EMBED": // we don't need Courier to process the embed code - it's pure HTML break; case "LINK": mortarItem.RawValue = ConvertIdentifier(mortarItem.RawValue, item, direction, ItemProviderIds.documentItemProviderGuid, "Document"); break; case "MEDIA": mortarItem.RawValue = ConvertIdentifier(mortarItem.RawValue, item, direction, ItemProviderIds.mediaItemProviderGuid, "Media"); break; case "RICHTEXT": // From the 'MortarValueConverter' it appears that the DocumentTypeAlias, // PropertyEditorAlias and PropertyTypeAlias are all constants, so we reuse them here. mortarItem.RawValue = ResolvePropertyItemData( item, propertyItemProvider, mortarItem.RawValue, Constants.PropertyEditors.TinyMCEAlias, "bodyText", Guid.Empty, direction); break; default: break; } } } } propertyData.Value = JsonConvert.SerializeObject(mortarValue); } }
private void ProcessProperty(Item item, ContentProperty propertyData, Direction direction) { var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ItemProviderIds.propertyDataItemProviderGuid, ExecutionContext); if (direction == Direction.Packaging) item.Dependencies.Add(propertyData.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid); var array = JsonConvert.DeserializeObject<JArray>(propertyData.Value.ToString()); foreach (var ncObj in array) { var doctypeAlias = ncObj["ncContentTypeAlias"].ToString(); var doctype = ExecutionContext.DatabasePersistence.RetrieveItem<DocumentType>(new ItemIdentifier(doctypeAlias, ItemProviderIds.documentTypeItemProviderGuid)); if (doctype == null) continue; foreach (var propertyType in doctype.Properties) { object o; if ((o = ncObj[propertyType.Alias]) != null) { //make fake item var value = o.ToString(); var datatype = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>( new ItemIdentifier(propertyType.DataTypeDefinitionId.ToString(), ItemProviderIds.dataTypeItemProviderGuid)); var fakeItem = new ContentPropertyData { ItemId = item.ItemId, Name = string.Format("{0} [{1}: Nested {2} ({3})]", item.Name, EditorAlias, datatype.PropertyEditorAlias, propertyType.Alias), Data = new List<ContentProperty> { new ContentProperty { Alias = propertyType.Alias, DataType = datatype.UniqueID, PropertyEditorAlias = datatype.PropertyEditorAlias, Value = value } } }; if (direction == Direction.Packaging) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.PackagingItem(fakeItem, propertyItemProvider); } catch (Exception ex) { CourierLogHelper.Error<NestedContentDataResolverProvider>( string.Concat("Error packaging data value: ", fakeItem.Name), ex); } } else if (direction == Direction.Extracting) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.ExtractingItem(fakeItem, propertyItemProvider); } catch (Exception ex) { CourierLogHelper.Error<NestedContentDataResolverProvider>( string.Concat("Error extracting data value: ", fakeItem.Name), ex); } } // pass up the dependencies and resources item.Dependencies.AddRange(fakeItem.Dependencies); item.Resources.AddRange(fakeItem.Resources); if (fakeItem.Data != null && fakeItem.Data.Any()) { var firstDataType = fakeItem.Data.FirstOrDefault(); if (firstDataType != null) { // set the resolved property data value string serializedValue = firstDataType.Value as string ?? JsonConvert.SerializeObject(firstDataType.Value); ncObj[propertyType.Alias] = new JValue(serializedValue); // (if packaging) add a dependency for the property's data-type if (direction == Direction.Packaging) item.Dependencies.Add(firstDataType.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid); } } } } } propertyData.Value = JsonConvert.SerializeObject(array); }
public override void PackagingProperty(Item item, ContentProperty propertyData) { ProcessProperty(item, propertyData, Direction.Packaging); }
private void ReplacePropertyDataIds(Item item, ContentProperty propertyData, Direction direction) { if (propertyData != null && propertyData.Value != null) { var dataTypeId = ExecutionContext.DatabasePersistence.GetNodeId(propertyData.DataType, NodeObjectTypes.DataType); var fakePropertyType = this.CreateDummyPropertyType(dataTypeId, this.EditorAlias); var converter = new ArchetypeValueConverter(); var archetype = (ArchetypeModel)converter.ConvertDataToSource(fakePropertyType, propertyData.Value, false); if (archetype != null) { // get the `PropertyItemProvider` from the collection. var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ProviderIDCollection.propertyDataItemProviderGuid, this.ExecutionContext); foreach (var property in archetype.Fieldsets.SelectMany(x => x.Properties)) { if (property == null || string.IsNullOrWhiteSpace(property.PropertyEditorAlias)) continue; // create a 'fake' item for Courier to process var fakeItem = new ContentPropertyData() { ItemId = item.ItemId, Name = string.Format("{0} [{1}: Nested {2} ({3})]", new[] { item.Name, this.EditorAlias, property.PropertyEditorAlias, property.Alias }), Data = new List<ContentProperty> { new ContentProperty { Alias = property.Alias, DataType = ExecutionContext.DatabasePersistence.GetUniqueId(property.DataTypeId, NodeObjectTypes.DataType), PropertyEditorAlias = property.PropertyEditorAlias, Value = property.Value } } }; if (direction == Direction.Packaging) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.PackagingItem(fakeItem, propertyItemProvider); } catch (Exception ex) { LogHelper.Error<ArchetypeDataResolver>(string.Concat("Error packaging data value: ", fakeItem.Name), ex); } // pass up the dependencies and resources item.Dependencies.AddRange(fakeItem.Dependencies); item.Resources.AddRange(fakeItem.Resources); } else if (direction == Direction.Extracting) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.ExtractingItem(fakeItem, propertyItemProvider); } catch (Exception ex) { LogHelper.Error<ArchetypeDataResolver>(string.Concat("Error extracting data value: ", fakeItem.Name), ex); } } if (fakeItem.Data != null && fakeItem.Data.Any()) { var firstDataType = fakeItem.Data.FirstOrDefault(); if (firstDataType != null) { // set the resolved property data value property.Value = firstDataType.Value; // (if packaging) add a dependency for the property's data-type if (direction == Direction.Packaging) item.Dependencies.Add(firstDataType.DataType.ToString(), ProviderIDCollection.dataTypeItemProviderGuid); } } } // serialize the Archetype back to a string propertyData.Value = archetype.SerializeForPersistence(); } } }
private void ReplacePropertyDataIds(Item item, ContentProperty propertyData, Direction direction) { if (propertyData != null && propertyData.Value != null) { // just look at the amount of dancing around we have to do in order to fake a `PublishedPropertyType`?! var dataTypeId = PersistenceManager.Default.GetNodeId(propertyData.DataType, NodeObjectTypes.DataType); var fakePropertyType = this.CreateDummyPropertyType(dataTypeId, this.EditorAlias); var converter = new ArchetypeValueConverter(); var archetype = (ArchetypeModel)converter.ConvertDataToSource(fakePropertyType, propertyData.Value, false); if (archetype != null) { // create a 'fake' provider, as ultimately only the 'Packaging' enum will be referenced. var fakeItemProvider = new PropertyItemProvider(); foreach (var property in archetype.Fieldsets.SelectMany(x => x.Properties)) { if (property == null || string.IsNullOrWhiteSpace(property.PropertyEditorAlias)) continue; // create a 'fake' item for Courier to process var fakeItem = new ContentPropertyData() { ItemId = item.ItemId, Name = string.Format("{0} [{1}: Nested {2} ({3})]", new[] { item.Name, this.EditorAlias, property.PropertyEditorAlias, property.Alias }), Data = new List<ContentProperty> { new ContentProperty { Alias = property.Alias, DataType = PersistenceManager.Default.GetUniqueId(property.DataTypeId, NodeObjectTypes.DataType), PropertyEditorAlias = property.PropertyEditorAlias, Value = property.Value } } }; if (direction == Direction.Packaging) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.PackagingItem(fakeItem, fakeItemProvider); } catch (Exception ex) { LogHelper.Error<ArchetypeDataResolver>(string.Concat("Error packaging data value: ", fakeItem.Name), ex); } // pass up the dependencies and resources item.Dependencies.AddRange(fakeItem.Dependencies); item.Resources.AddRange(fakeItem.Resources); } else if (direction == Direction.Extracting) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.ExtractingItem(fakeItem, fakeItemProvider); } catch (Exception ex) { LogHelper.Error<ArchetypeDataResolver>(string.Concat("Error extracting data value: ", fakeItem.Name), ex); } } if (fakeItem.Data != null && fakeItem.Data.Any()) { var firstDataType = fakeItem.Data.FirstOrDefault(); if (firstDataType != null) { // set the resolved property data value property.Value = firstDataType.Value; // (if packaging) add a dependency for the property's data-type if (direction == Direction.Packaging) item.Dependencies.Add(firstDataType.DataType.ToString(), ProviderIDCollection.dataTypeItemProviderGuid); } } } if (item.Name.Contains(string.Concat(this.EditorAlias, ": Nested"))) { // if the Archetype is nested, then we only want to return the object itself - not a serialized string propertyData.Value = archetype; } else { // if the Archetype is the root/container, then we can serialize it to a string propertyData.Value = archetype.SerializeForPersistence(); } } } }
public virtual void PackagingProperty(Item item, ContentProperty propertyData) { }
public virtual void ExtractingProperty(Item item, ContentProperty propertyData) { }
private void DeserializeContents(WorkflowMarkupSerializationManager serializationManager, object obj, XmlReader reader) { if (serializationManager == null) throw new ArgumentNullException("serializationManager"); if (obj == null) throw new ArgumentNullException("obj"); if (reader == null) throw new ArgumentNullException("reader"); if (reader.NodeType != XmlNodeType.Element) return; // get the serializer WorkflowMarkupSerializer serializer = serializationManager.GetSerializer(obj.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; if (serializer == null) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNotAvailable, obj.GetType().FullName), reader)); return; } try { serializer.OnBeforeDeserialize(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } bool isEmptyElement = reader.IsEmptyElement; string elementNamespace = reader.NamespaceURI; List<PropertyInfo> props = new List<PropertyInfo>(); List<EventInfo> events = new List<EventInfo>(); // Add the extended properties for primitive types if (obj.GetType().IsPrimitive || obj.GetType() == typeof(string) || obj.GetType() == typeof(decimal) || obj.GetType().IsEnum || obj.GetType() == typeof(DateTime) || obj.GetType() == typeof(TimeSpan) || obj.GetType() == typeof(Guid)) { props.AddRange(serializationManager.GetExtendedProperties(obj)); } else { try { props.AddRange(serializer.GetProperties(serializationManager, obj)); props.AddRange(serializationManager.GetExtendedProperties(obj)); events.AddRange(serializer.GetEvents(serializationManager, obj)); } catch (Exception e) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerThrewException, obj.GetType(), e.Message), e, reader)); return; } } //First we try to deserialize simple properties if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { // if (reader.LocalName.Equals("xmlns", StringComparison.Ordinal) || reader.Prefix.Equals("xmlns", StringComparison.Ordinal)) continue; // XmlQualifiedName xmlQualifiedName = new XmlQualifiedName(reader.LocalName, reader.LookupNamespace(reader.Prefix)); if (xmlQualifiedName.Namespace.Equals(StandardXomlKeys.Definitions_XmlNs, StringComparison.Ordinal) && !IsMarkupExtension(xmlQualifiedName) && !ExtendedPropertyInfo.IsExtendedProperty(serializationManager, props, xmlQualifiedName) && !ExtendedPropertyInfo.IsExtendedProperty(serializationManager, xmlQualifiedName)) { serializationManager.FireFoundDefTag(new WorkflowMarkupElementEventArgs(reader)); continue; } //For simple properties we assume that if . indicates string propName = XmlConvert.DecodeName(reader.LocalName); string propVal = reader.Value; DependencyProperty dependencyProperty = ResolveDependencyProperty(serializationManager, reader, obj, propName); if (dependencyProperty != null) { serializationManager.Context.Push(dependencyProperty); try { if (dependencyProperty.IsEvent) DeserializeEvent(serializationManager, reader, obj, propVal); else DeserializeSimpleProperty(serializationManager, reader, obj, propVal); } finally { Debug.Assert(serializationManager.Context.Current == dependencyProperty, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } else { PropertyInfo property = WorkflowMarkupSerializer.LookupProperty(props, propName); if (property != null) { serializationManager.Context.Push(property); try { DeserializeSimpleProperty(serializationManager, reader, obj, propVal); } finally { Debug.Assert((PropertyInfo)serializationManager.Context.Current == property, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } else { EventInfo evt = WorkflowMarkupSerializer.LookupEvent(events, propName); if (events != null && evt != null) { serializationManager.Context.Push(evt); try { DeserializeEvent(serializationManager, reader, obj, propVal); } finally { Debug.Assert((EventInfo)serializationManager.Context.Current == evt, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } else serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerNoMemberFound, new object[] { propName, obj.GetType().FullName }), reader)); } } } } try { serializer.OnBeforeDeserializeContents(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } //Now deserialize compound properties try { serializer.ClearChildren(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_SerializerThrewException, obj.GetType(), e.Message), e, reader)); return; } using (ContentProperty contentProperty = new ContentProperty(serializationManager, serializer, obj)) { List<ContentInfo> contents = new List<ContentInfo>(); if (!isEmptyElement) { reader.MoveToElement(); int initialDepth = reader.Depth; XmlQualifiedName extendedPropertyQualifiedName = new XmlQualifiedName(reader.LocalName, reader.LookupNamespace(reader.Prefix)); do { // Extended property should be deserialized, this is required for primitive types which have extended property as children // We should not ignore if (extendedPropertyQualifiedName != null && !ExtendedPropertyInfo.IsExtendedProperty(serializationManager, extendedPropertyQualifiedName)) { extendedPropertyQualifiedName = null; continue; } // this will make it to skip all the nodes if ((initialDepth + 1) < reader.Depth) { bool unnecessaryXmlFound = false; while (reader.Read() && ((initialDepth + 1) < reader.Depth)) { // Ignore comments and whitespaces if (reader.NodeType != XmlNodeType.Comment && reader.NodeType != XmlNodeType.Whitespace && !unnecessaryXmlFound) { serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_InvalidDataFoundForType, obj.GetType().FullName), reader)); unnecessaryXmlFound = true; } } } //Push all the PIs into stack so that they are available for type resolution AdvanceReader(reader); if (reader.NodeType == XmlNodeType.Element) { //We should only support A.B syntax for compound properties, all others are treated as content XmlQualifiedName xmlQualifiedName = new XmlQualifiedName(reader.LocalName, reader.LookupNamespace(reader.Prefix)); int index = reader.LocalName.IndexOf('.'); if (index > 0 || ExtendedPropertyInfo.IsExtendedProperty(serializationManager, xmlQualifiedName)) { string propertyName = reader.LocalName.Substring(reader.LocalName.IndexOf('.') + 1); PropertyInfo property = WorkflowMarkupSerializer.LookupProperty(props, propertyName); DependencyProperty dependencyProperty = ResolveDependencyProperty(serializationManager, reader, obj, reader.LocalName); if (dependencyProperty == null && property == null) serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_InvalidElementFoundForType, reader.LocalName, obj.GetType().FullName), reader)); else if (dependencyProperty != null) { PropertyInfo prop = WorkflowMarkupSerializer.LookupProperty(props, dependencyProperty.Name); //Deserialize the dynamic property serializationManager.Context.Push(dependencyProperty); try { DeserializeCompoundProperty(serializationManager, reader, obj); } finally { Debug.Assert(serializationManager.Context.Current == dependencyProperty, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } else if (property != null) { //Deserialize the compound property serializationManager.Context.Push(property); try { DeserializeCompoundProperty(serializationManager, reader, obj); } finally { Debug.Assert((PropertyInfo)serializationManager.Context.Current == property, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } } else { //Deserialize the children int lineNumber = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1; int linePosition = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1; object obj2 = DeserializeObject(serializationManager, reader); if (obj2 != null) { obj2 = GetValueFromMarkupExtension(serializationManager, obj2); if (obj2 != null && obj2.GetType() == typeof(string) && ((string)obj2).StartsWith("{}", StringComparison.Ordinal)) obj2 = ((string)obj2).Substring(2); contents.Add(new ContentInfo(obj2, lineNumber, linePosition)); } } } else if (reader.NodeType == XmlNodeType.Text && contentProperty.Property != null) { //If we read the string then we should not advance the reader further instead break int lineNumber = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LineNumber : 1; int linePosition = (reader is IXmlLineInfo) ? ((IXmlLineInfo)reader).LinePosition : 1; contents.Add(new ContentInfo(reader.ReadString(), lineNumber, linePosition)); if (initialDepth >= reader.Depth) break; } else { if (reader.NodeType == XmlNodeType.Entity || reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA) serializationManager.ReportError(CreateSerializationError(SR.GetString(SR.Error_InvalidDataFound, reader.Value.Trim(), obj.GetType().FullName), reader)); } } while (reader.Read() && initialDepth < reader.Depth); } //Make sure that we set contents contentProperty.SetContents(contents); } try { serializer.OnAfterDeserialize(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } }
/// <summary> /// Replaces the property data Ids. /// </summary> /// <param name="item">The item.</param> /// <param name="propertyData">The property data.</param> /// <param name="direction">The direction.</param> private void ReplacePropertyDataIds(Item item, ContentProperty propertyData, Direction direction) { if (propertyData != null && propertyData.Value != null) { var dataType = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>(new ItemIdentifier(propertyData.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid)); //Fetch the Prevalues for the current Property's DataType (if its an 'Archetype config') var prevalue = dataType.Prevalues.FirstOrDefault(x => x.Alias.ToLowerInvariant().Equals("archetypeconfig")); var archetypePreValue = prevalue == null ? null : JsonConvert.DeserializeObject<ArchetypePreValue>(prevalue.Value, ArchetypeHelper.Instance.JsonSerializerSettings); RetrieveAdditionalProperties(ref archetypePreValue); //Deserialize the value of the current Property to an ArchetypeModel and set additional properties before converting values var sourceJson = propertyData.Value.ToString(); var archetype = JsonConvert.DeserializeObject<ArchetypeModel>(sourceJson, ArchetypeHelper.Instance.JsonSerializerSettings); RetrieveAdditionalProperties(ref archetype, archetypePreValue); if (archetype != null) { // get the `PropertyItemProvider` from the collection. var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ItemProviderIds.propertyDataItemProviderGuid, ExecutionContext); foreach (var property in archetype.Fieldsets.SelectMany(x => x.Properties)) { if (property == null || string.IsNullOrWhiteSpace(property.PropertyEditorAlias)) continue; // create a 'fake' item for Courier to process var fakeItem = new ContentPropertyData { ItemId = item.ItemId, Name = string.Format("{0} [{1}: Nested {2} ({3})]", new[] { item.Name, EditorAlias, property.PropertyEditorAlias, property.Alias }), Data = new List<ContentProperty> { new ContentProperty { Alias = property.Alias, DataType = ExecutionContext.DatabasePersistence.GetUniqueId(property.DataTypeId, UmbracoNodeObjectTypeIds.DataType), PropertyEditorAlias = property.PropertyEditorAlias, Value = property.Value } } }; if (direction == Direction.Packaging) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.PackagingItem(fakeItem, propertyItemProvider); } catch (Exception ex) { CourierLogHelper.Error<ArchetypeDataResolver>(string.Concat("Error packaging data value: ", fakeItem.Name), ex); } // pass up the dependencies and resources item.Dependencies.AddRange(fakeItem.Dependencies); item.Resources.AddRange(fakeItem.Resources); } else if (direction == Direction.Extracting) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.ExtractingItem(fakeItem, propertyItemProvider); } catch (Exception ex) { CourierLogHelper.Error<ArchetypeDataResolver>(string.Concat("Error extracting data value: ", fakeItem.Name), ex); } } if (fakeItem.Data != null && fakeItem.Data.Any()) { var firstDataType = fakeItem.Data.FirstOrDefault(); if (firstDataType != null) { // set the resolved property data value property.Value = firstDataType.Value; // (if packaging) add a dependency for the property's data-type if (direction == Direction.Packaging) item.Dependencies.Add(firstDataType.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid); } } } // serialize the Archetype back to a string propertyData.Value = archetype.SerializeForPersistence(); } } }
internal void SerializeContents(WorkflowMarkupSerializationManager serializationManager, object obj, XmlWriter writer, bool dictionaryKey) { if (serializationManager == null) throw new ArgumentNullException("serializationManager"); if (obj == null) throw new ArgumentNullException("obj"); if (writer == null) throw new ArgumentNullException("writer"); WorkflowMarkupSerializer serializer = null; try { //Now get the serializer to persist the properties, if the serializer is not found then we dont serialize the properties serializer = serializationManager.GetSerializer(obj.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } if (serializer == null) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, obj.GetType().FullName))); return; } try { serializer.OnBeforeSerialize(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } Hashtable allProperties = new Hashtable(); ArrayList complexProperties = new ArrayList(); IDictionary<DependencyProperty, object> dependencyProperties = null; List<PropertyInfo> properties = new List<PropertyInfo>(); List<EventInfo> events = new List<EventInfo>(); Hashtable designTimeTypeNames = null; // Serialize the extended properties for primitive types also if (obj.GetType().IsPrimitive || obj.GetType() == typeof(string) || obj.GetType() == typeof(decimal) || obj.GetType() == typeof(DateTime) || obj.GetType() == typeof(TimeSpan) || obj.GetType().IsEnum || obj.GetType() == typeof(Guid)) { if (obj.GetType() == typeof(char) || obj.GetType() == typeof(byte) || obj.GetType() == typeof(System.Int16) || obj.GetType() == typeof(decimal) || obj.GetType() == typeof(DateTime) || obj.GetType() == typeof(TimeSpan) || obj.GetType().IsEnum || obj.GetType() == typeof(Guid)) { //These non CLS-compliant are not supported in the XmlWriter if ((obj.GetType() != typeof(char)) || (char)obj != '\0') { //These non CLS-compliant are not supported in the XmlReader string stringValue = String.Empty; if (obj.GetType() == typeof(DateTime)) { stringValue = ((DateTime)obj).ToString("o", CultureInfo.InvariantCulture); } else { TypeConverter typeConverter = TypeDescriptor.GetConverter(obj.GetType()); if (typeConverter != null && typeConverter.CanConvertTo(typeof(string))) stringValue = typeConverter.ConvertTo(null, CultureInfo.InvariantCulture, obj, typeof(string)) as string; else stringValue = Convert.ToString(obj, CultureInfo.InvariantCulture); } writer.WriteValue(stringValue); } } else if (obj.GetType() == typeof(string)) { string attribValue = obj as string; attribValue = attribValue.Replace('\0', ' '); if (!(attribValue.StartsWith("{", StringComparison.Ordinal) && attribValue.EndsWith("}", StringComparison.Ordinal))) writer.WriteValue(attribValue); else writer.WriteValue("{}" + attribValue); } else { writer.WriteValue(obj); } // For Key properties, we don;t want to get the extended properties if (!dictionaryKey) properties.AddRange(serializationManager.GetExtendedProperties(obj)); } else { // Serialize properties //We first get all the properties, once we have them all, we start distinguishing between //simple and complex properties, the reason for that is XmlWriter needs to write attributes //first and elements later // Dependency events are treated as the same as dependency properties. try { if (obj is DependencyObject && ((DependencyObject)obj).UserData.Contains(UserDataKeys.DesignTimeTypeNames)) designTimeTypeNames = ((DependencyObject)obj).UserData[UserDataKeys.DesignTimeTypeNames] as Hashtable; dependencyProperties = serializer.GetDependencyProperties(serializationManager, obj); properties.AddRange(serializer.GetProperties(serializationManager, obj)); // For Key properties, we don;t want to get the extended properties if (!dictionaryKey) properties.AddRange(serializationManager.GetExtendedProperties(obj)); events.AddRange(serializer.GetEvents(serializationManager, obj)); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } } if (dependencyProperties != null) { // For attached properties that does not have a corresponding real property on the object, if the value is a design time // type, it may not be set through dependency property SetValue, therefore will not be present in the dependencyProperties // collection, we'll have to get the dependency property object ourselves. if (designTimeTypeNames != null) { foreach (object key in designTimeTypeNames.Keys) { DependencyProperty dependencyProperty = key as DependencyProperty; if (dependencyProperty != null && !dependencyProperties.ContainsKey(dependencyProperty)) dependencyProperties.Add(dependencyProperty, designTimeTypeNames[dependencyProperty]); } } // Add all dependency properties to the master collection. foreach (DependencyProperty dependencyProperty in dependencyProperties.Keys) { string propertyName = String.Empty; if (dependencyProperty.IsAttached) { string prefix = String.Empty; XmlQualifiedName qualifiedName = serializationManager.GetXmlQualifiedName(dependencyProperty.OwnerType, out prefix); propertyName = qualifiedName.Name + "." + dependencyProperty.Name; } else { propertyName = dependencyProperty.Name; } if (dependencyProperty.IsAttached || !dependencyProperty.DefaultMetadata.IsMetaProperty) allProperties.Add(propertyName, dependencyProperty); } } if (properties != null) { foreach (PropertyInfo propInfo in properties) { // Do not serialize properties that have corresponding dynamic properties. if (propInfo != null && !allProperties.ContainsKey(propInfo.Name)) allProperties.Add(propInfo.Name, propInfo); } } if (events != null) { foreach (EventInfo eventInfo in events) { // Do not serialize events that have corresponding dynamic properties. if (eventInfo != null && !allProperties.ContainsKey(eventInfo.Name)) allProperties.Add(eventInfo.Name, eventInfo); } } using (ContentProperty contentProperty = new ContentProperty(serializationManager, serializer, obj)) { foreach (object propertyObj in allProperties.Values) { string propertyName = String.Empty; object propertyValue = null; Type propertyInfoType = null; try { if (propertyObj is PropertyInfo) { PropertyInfo property = propertyObj as PropertyInfo; // If the property has parameters we can not serialize it , we just move on. ParameterInfo[] indexParameters = property.GetIndexParameters(); if (indexParameters != null && indexParameters.Length > 0) continue; propertyName = property.Name; propertyValue = null; if (property.CanRead) { propertyValue = property.GetValue(obj, null); if (propertyValue == null && TypeProvider.IsAssignable(typeof(Type), property.PropertyType)) { // See if we have a design time value for the property DependencyProperty dependencyProperty = DependencyProperty.FromName(property.Name, property.ReflectedType); if (dependencyProperty != null) propertyValue = Helpers.GetDesignTimeTypeName(obj, dependencyProperty); if (propertyValue == null) { string key = property.ReflectedType.FullName + "." + property.Name; propertyValue = Helpers.GetDesignTimeTypeName(obj, key); } if (propertyValue != null) propertyValue = new TypeExtension((string)propertyValue); } } propertyInfoType = property.PropertyType; } else if (propertyObj is EventInfo) { EventInfo evt = propertyObj as EventInfo; propertyName = evt.Name; propertyValue = WorkflowMarkupSerializationHelpers.GetEventHandlerName(obj, evt.Name); if ((propertyValue == null || (propertyValue is string && string.IsNullOrEmpty((string)propertyValue))) && obj is DependencyObject) { // The object is not created through deserialization, we should check to see if the delegate is // created and added to list. We can only serialize the handler if its target type is the same // as the activity type that's be designed. DependencyProperty dependencyProperty = DependencyProperty.FromName(propertyName, obj.GetType()); if (dependencyProperty != null) { Activity activity = serializationManager.Context[typeof(Activity)] as Activity; Delegate handler = ((DependencyObject)obj).GetHandler(dependencyProperty) as Delegate; if (handler != null && activity != null && TypeProvider.Equals(handler.Target.GetType(), Helpers.GetRootActivity(activity).GetType())) propertyValue = handler; } } propertyInfoType = evt.EventHandlerType; } else if (propertyObj is DependencyProperty) { DependencyProperty dependencyProperty = propertyObj as DependencyProperty; propertyName = dependencyProperty.Name; propertyValue = dependencyProperties[dependencyProperty]; propertyInfoType = dependencyProperty.PropertyType; } } catch (Exception e) { while (e is TargetInvocationException && e.InnerException != null) e = e.InnerException; serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerPropertyGetFailed, new object[] { propertyName, obj.GetType().FullName, e.Message }))); continue; } if (propertyObj is PropertyInfo && contentProperty.Property == (PropertyInfo)propertyObj) continue; Type propertyValueType = null; if (propertyValue != null) { propertyValue = GetMarkupExtensionFromValue(propertyValue); propertyValueType = propertyValue.GetType(); } else if (propertyObj is PropertyInfo) { propertyValue = new NullExtension(); propertyValueType = propertyValue.GetType(); Attribute[] attributes = Attribute.GetCustomAttributes(propertyObj as PropertyInfo, typeof(DefaultValueAttribute), true); if (attributes.Length > 0) { DefaultValueAttribute defaultValueAttr = attributes[0] as DefaultValueAttribute; if (defaultValueAttr.Value == null) propertyValue = null; } } if (propertyValue != null) propertyValueType = propertyValue.GetType(); //Now get the serializer to persist the properties, if the serializer is not found then we dont serialize the properties serializationManager.Context.Push(propertyObj); WorkflowMarkupSerializer propValueSerializer = null; try { propValueSerializer = serializationManager.GetSerializer(propertyValueType, typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); serializationManager.Context.Pop(); continue; } if (propValueSerializer == null) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, propertyValueType.FullName))); serializationManager.Context.Pop(); continue; } // ask serializer if we can serialize try { if (propValueSerializer.ShouldSerializeValue(serializationManager, propertyValue)) { //NOTE: THE FOLLOWING CONDITION ABOUT propertyInfoType != typeof(object) is VALID AS WE SHOULD NOT SERIALIZE A PROPERTY OF TYPE OBJECT TO STRING //IF WE DO THAT THEN WE DO NOT KNOWN WHAT WAS THE TYPE OF ORIGINAL OBJECT AND SERIALIZER WONT BE ABLE TO GET THE STRING BACK INTO THE CORRECT TYPE, //AS THE TYPE INFORMATION IS LOST if (propValueSerializer.CanSerializeToString(serializationManager, propertyValue) && propertyInfoType != typeof(object)) { using (new SafeXmlNodeWriter(serializationManager, obj, propertyObj, XmlNodeType.Attribute)) { //This is a work around to special case the markup extension serializer as it writes to the stream using writer if (propValueSerializer is MarkupExtensionSerializer) { propValueSerializer.SerializeToString(serializationManager, propertyValue); } else { string stringValue = propValueSerializer.SerializeToString(serializationManager, propertyValue); if (!string.IsNullOrEmpty(stringValue)) { stringValue = stringValue.Replace('\0', ' '); if (propertyValue is MarkupExtension || !(stringValue.StartsWith("{", StringComparison.Ordinal) && stringValue.EndsWith("}", StringComparison.Ordinal))) writer.WriteString(stringValue); else writer.WriteString("{}" + stringValue); } } } } else { complexProperties.Add(propertyObj); } } } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNoSerializeLogic, new object[] { propertyName, obj.GetType().FullName }), e)); } finally { Debug.Assert(serializationManager.Context.Current == propertyObj, "Serializer did not remove an object it pushed into stack."); serializationManager.Context.Pop(); } } try { serializer.OnBeforeSerializeContents(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } // serialize compound properties as child elements of the current node. foreach (object propertyObj in complexProperties) { // get value and check for null string propertyName = String.Empty; object propertyValue = null; Type ownerType = null; bool isReadOnly = false; try { if (propertyObj is PropertyInfo) { PropertyInfo property = propertyObj as PropertyInfo; propertyName = property.Name; propertyValue = property.CanRead ? property.GetValue(obj, null) : null; ownerType = obj.GetType(); isReadOnly = (!property.CanWrite); } else if (propertyObj is DependencyProperty) { DependencyProperty dependencyProperty = propertyObj as DependencyProperty; propertyName = dependencyProperty.Name; propertyValue = dependencyProperties[dependencyProperty]; ownerType = dependencyProperty.OwnerType; isReadOnly = ((dependencyProperty.DefaultMetadata.Options & DependencyPropertyOptions.ReadOnly) == DependencyPropertyOptions.ReadOnly); } } catch (Exception e) { while (e is TargetInvocationException && e.InnerException != null) e = e.InnerException; serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerPropertyGetFailed, propertyName, ownerType.FullName, e.Message))); continue; } if (propertyObj is PropertyInfo && (PropertyInfo)propertyObj == contentProperty.Property) continue; if (propertyValue != null) { propertyValue = GetMarkupExtensionFromValue(propertyValue); WorkflowMarkupSerializer propValueSerializer = serializationManager.GetSerializer(propertyValue.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; if (propValueSerializer != null) { using (new SafeXmlNodeWriter(serializationManager, obj, propertyObj, XmlNodeType.Element)) { if (isReadOnly) propValueSerializer.SerializeContents(serializationManager, propertyValue, writer, false); else propValueSerializer.SerializeObject(serializationManager, propertyValue, writer); } } else { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, propertyValue.GetType().FullName))); } } } // serialize the contents try { object contents = contentProperty.GetContents(); if (contents != null) { contents = GetMarkupExtensionFromValue(contents); WorkflowMarkupSerializer propValueSerializer = serializationManager.GetSerializer(contents.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; if (propValueSerializer == null) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, contents.GetType()))); } else { // //NOTE: THE FOLLOWING CONDITION ABOUT contentProperty.Property.PropertyType != typeof(object) is VALID AS WE SHOULD NOT SERIALIZE A PROPERTY OF TYPE OBJECT TO STRING //IF WE DO THAT THEN WE DO NOT KNOWN WHAT WAS THE TYPE OF ORIGINAL OBJECT AND SERIALIZER WONT BE ABLE TO GET THE STRING BACK INTO THE CORRECT TYPE, //AS THE TYPE INFORMATION IS LOST if (propValueSerializer.CanSerializeToString(serializationManager, contents) && (contentProperty.Property == null || contentProperty.Property.PropertyType != typeof(object))) { string stringValue = propValueSerializer.SerializeToString(serializationManager, contents); if (!string.IsNullOrEmpty(stringValue)) { stringValue = stringValue.Replace('\0', ' '); if (contents is MarkupExtension || !(stringValue.StartsWith("{", StringComparison.Ordinal) && stringValue.EndsWith("}", StringComparison.Ordinal))) writer.WriteString(stringValue); else writer.WriteString("{}" + stringValue); } } else if (CollectionMarkupSerializer.IsValidCollectionType(contents.GetType())) { if (contentProperty.Property == null) { IEnumerable enumerableContents = contents as IEnumerable; foreach (object childObj in enumerableContents) { if (childObj == null) { SerializeObject(serializationManager, new NullExtension(), writer); } else { object childObj2 = childObj; bool dictionaryEntry = (childObj2 is DictionaryEntry); try { if (dictionaryEntry) { serializationManager.WorkflowMarkupStack.Push(childObj); childObj2 = ((DictionaryEntry)childObj2).Value; } childObj2 = GetMarkupExtensionFromValue(childObj2); WorkflowMarkupSerializer childObjectSerializer = serializationManager.GetSerializer(childObj2.GetType(), typeof(WorkflowMarkupSerializer)) as WorkflowMarkupSerializer; if (childObjectSerializer != null) childObjectSerializer.SerializeObject(serializationManager, childObj2, writer); else serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerNotAvailableForSerialize, childObj2.GetType()))); } finally { if (dictionaryEntry) serializationManager.WorkflowMarkupStack.Pop(); } } } } else { propValueSerializer.SerializeContents(serializationManager, contents, writer, false); } } else { propValueSerializer.SerializeObject(serializationManager, contents, writer); } } } } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } } try { serializer.OnAfterSerialize(serializationManager, obj); } catch (Exception e) { serializationManager.ReportError(new WorkflowMarkupSerializationException(SR.GetString(SR.Error_SerializerThrewException, obj.GetType().FullName, e.Message), e)); return; } }
/// <summary> /// Extractings the property. /// </summary> /// <param name="item">The item.</param> /// <param name="propertyData">The property data.</param> public override void ExtractingProperty(Item item, ContentProperty propertyData) { ReplacePropertyDataIds(item, propertyData, Direction.Extracting); }
public override void ExtractingProperty(Item item, ContentProperty propertyData) { ProcessProperty(item, propertyData, Direction.Extracting); }
public override void PackagingProperty(Item item, ContentProperty propertyData) { ResolvePropertyData(item, propertyData, Direction.Packaging); }
private HashSet<ContentProperty> GetNodeProperties(int id, HiveId selectedTemplateId) { var customProperties = new List<ContentProperty>(); var tabIds = _docTypes.SelectMany(tabs => tabs.DefinedTabs).Select(x => x.Id).ToList(); var currTab = 0; var node = XmlData.Root.Descendants() .Where(x => (string)x.Attribute("id") == id.ToString()) .Single(); var docTypeArray = _docTypes.ToArray(); //get the corresponding doc type for this node var docType = docTypeArray .Where(x => x.Id == HiveId.ConvertIntToGuid(int.Parse((string)node.Attribute("nodeType")))) .Single(); //add node name var nodeName = new ContentProperty((HiveId)Guid.NewGuid(), docType.Properties.Where(x => x.Alias == NodeNameAttributeDefinition.AliasValue).Single(), new Dictionary<string, object> { { "Name", (string)node.Attribute("nodeName") } }) { Name = NodeNameAttributeDefinition.AliasValue, Alias = NodeNameAttributeDefinition.AliasValue, TabId = docType.DefinedTabs.Where(x => x.Alias == _generalGroup.Alias).Single().Id }; customProperties.Add(nodeName); //add selected template (empty) var selectedTemplate = new ContentProperty((HiveId)Guid.NewGuid(), docType.Properties.Where(x => x.Alias == SelectedTemplateAttributeDefinition.AliasValue).Single(), selectedTemplateId.IsNullValueOrEmpty() ? new Dictionary<string, object>() : new Dictionary<string, object> { { "TemplateId", selectedTemplateId.ToString() } }) { Name = SelectedTemplateAttributeDefinition.AliasValue, Alias = SelectedTemplateAttributeDefinition.AliasValue, TabId = docType.DefinedTabs.Where(x => x.Alias == _generalGroup.Alias).Single().Id }; customProperties.Add(selectedTemplate); customProperties.AddRange( node.Elements() .Where(e => e.Attribute("isDoc") == null) .Select(e => { //Assigning the doc type properties is completely arbitrary here, all I'm doing is //aligning a DocumentTypeProperty that contains the DataType that I want to render ContentProperty np; DocumentTypeProperty dp; switch (e.Name.LocalName) { case "bodyText": //dp = new DocumentTypeProperty(new HiveId(Guid.NewGuid()), _dataTypes[0]); dp = docType.Properties.Where(x => x.Alias == "bodyText").Single(); np = new ContentProperty((HiveId)GetNodeProperty(e), dp, e.Value); break; case "colorSwatchPicker": //dp = new DocumentTypeProperty(new HiveId(Guid.NewGuid()), _dataTypes[2]); dp = docType.Properties.Where(x => x.Alias == "colorSwatchPicker").Single(); np = new ContentProperty((HiveId)GetNodeProperty(e), dp, e.Value); break; case "tags": //dp = new DocumentTypeProperty(new HiveId(Guid.NewGuid()), _dataTypes[3]); dp = docType.Properties.Where(x => x.Alias == "tags").Single(); np = new ContentProperty((HiveId)GetNodeProperty(e), dp, e.Value); break; case "textBox": //dp = new DocumentTypeProperty(new HiveId(Guid.NewGuid()), _dataTypes[4]) { OverriddenPreValues = overridenPreVals }; dp = docType.Properties.Where(x => x.Alias == "textBox").Single(); np = new ContentProperty((HiveId)GetNodeProperty(e), dp, e.Value); break; case "publisher": //dp = new DocumentTypeProperty(new HiveId(Guid.NewGuid()), _dataTypes[4]) { OverriddenPreValues = overridenPreVals }; dp = docType.Properties.Where(x => x.Alias == "publisher").Single(); np = new ContentProperty((HiveId)GetNodeProperty(e), dp, e.Value); break; case "numberOfPages": //dp = new DocumentTypeProperty(new HiveId(Guid.NewGuid()), _dataTypes[4]) { OverriddenPreValues = overridenPreVals }; dp = docType.Properties.Where(x => x.Alias == "numberOfPages").Single(); np = new ContentProperty((HiveId)GetNodeProperty(e), dp, e.Value); break; case "image": //dp = new DocumentTypeProperty(new HiveId(Guid.NewGuid()), _dataTypes[4]) { OverriddenPreValues = overridenPreVals }; dp = docType.Properties.Where(x => x.Alias == "image").Single(); var values = e.Value.Split(','); np = new ContentProperty((HiveId)GetNodeProperty(e), dp, new Dictionary<string, object> { { "MediaId", values[0] }, { "Value", values[1] } }); break; default: //dp = new DocumentTypeProperty(new HiveId(Guid.NewGuid()), _dataTypes[1]); dp = docType.Properties.Where(x => x.Alias == e.Name.LocalName).Single(); np = new ContentProperty((HiveId)GetNodeProperty(e), dp, e.Value); break; } //need to set the data type model for this property np.Alias = e.Name.LocalName; np.Name = e.Name.LocalName; //add to a random tab currTab = 0; // currTab == 2 ? 0 : ++currTab; np.TabId = tabIds[currTab]; return np; }).ToList()); return new HashSet<ContentProperty>(customProperties); }
private void ProcessCell(Item item, ContentProperty propertyData, dynamic cell, Direction direction) { string docTypeId = cell?.value?.docType?.ToString(); string cellValue = cell?.value?.value?.ToString(); if (cellValue == null || docTypeId == null) return; var data = JsonConvert.DeserializeObject(cellValue); if (!(data is JObject)) return; var propValues = ((JObject)data).ToObject<Dictionary<string, object>>(); var docType = ExecutionContext.DatabasePersistence.RetrieveItem<DocumentType>( new ItemIdentifier(docTypeId, ItemProviderIds.documentTypeItemProviderGuid)); if (direction == Direction.Packaging) { item.Dependencies.Add(docTypeId, ItemProviderIds.documentTypeItemProviderGuid); //package doctype from guid to alias cell.value.docType = new JValue(docType.Alias); } else if (direction == Direction.Extracting) { //extract doctype from alias to guid cell.value.docType = new JValue(docType.UniqueId.ToString()); } var propertyItemProvider = ItemProviderCollection.Instance.GetProvider(ItemProviderIds.propertyDataItemProviderGuid, ExecutionContext); foreach (var prop in docType.Properties) { object value; if (!propValues.TryGetValue(prop.Alias, out value)) continue; var datatype = ExecutionContext.DatabasePersistence.RetrieveItem<DataType>( new ItemIdentifier( prop.DataTypeDefinitionId.ToString(), ItemProviderIds.dataTypeItemProviderGuid)); var fakeItem = new ContentPropertyData { ItemId = item.ItemId, Name = string.Format("{0} [{1}: Nested {2} ({3})]", item.Name, EditorAlias, datatype.PropertyEditorAlias, prop.Alias), Data = new List<ContentProperty> { new ContentProperty { Alias = prop.Alias, DataType = datatype.UniqueID, PropertyEditorAlias = datatype.PropertyEditorAlias, Value = value.ToString() } } }; if (direction == Direction.Packaging) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.PackagingItem(fakeItem, propertyItemProvider); } catch (Exception ex) { CourierLogHelper.Error<NestedContentDataResolverProvider>( string.Concat("Error packaging data value: ", fakeItem.Name), ex); } } else if (direction == Direction.Extracting) { try { // run the 'fake' item through Courier's data resolvers ResolutionManager.Instance.ExtractingItem(fakeItem, propertyItemProvider); } catch (Exception ex) { CourierLogHelper.Error<NestedContentDataResolverProvider>( string.Concat("Error extracting data value: ", fakeItem.Name), ex); } } // pass up the dependencies and resources item.Dependencies.AddRange(fakeItem.Dependencies); item.Resources.AddRange(fakeItem.Resources); if (fakeItem.Data != null && fakeItem.Data.Any()) { var firstDataType = fakeItem.Data.FirstOrDefault(); if (firstDataType != null) { // set the resolved property data value string serializedValue = firstDataType.Value as string ?? JsonConvert.SerializeObject(firstDataType.Value); object jsonValue; try { jsonValue = JsonConvert.DeserializeObject(serializedValue); } catch { jsonValue = serializedValue; } propValues[prop.Alias] = jsonValue; // (if packaging) add a dependency for the property's data-type if (direction == Direction.Packaging) item.Dependencies.Add(firstDataType.DataType.ToString(), ItemProviderIds.dataTypeItemProviderGuid); } } } var serialized = JsonConvert.SerializeObject(propValues); cell.value.value = JsonConvert.DeserializeObject(serialized); }
public override void ExtractingProperty(Item item, ContentProperty propertyData) { propertyData.Value = XmlDependencies.ReplaceIds(propertyData.Value.ToString(), "//* [@propertyid != '']", Core.Enums.IdentifierReplaceDirection.FromGuidToNodeId); }