public override void DeployModel(object modelHost, DefinitionBase model)
        {
            base.DeployModel(modelHost, model);

            var listItemModelHost = modelHost.WithAssertAndCast <ListItemModelHost>("modelHost", value => value.RequireNotNull());
            var typedDefinition   = model.WithAssertAndCast <ContentByQueryWebPartDefinition>("model", value => value.RequireNotNull());

            var pageItem = listItemModelHost.HostListItem;

            WithExistingWebPart(listItemModelHost.HostFile, typedDefinition, spObject =>
            {
                var assert = ServiceFactory.AssertService
                             .NewAssert(model, typedDefinition, spObject)
                             .ShouldNotBeNull(spObject);

                if (!string.IsNullOrEmpty(typedDefinition.ContentTypeBeginsWithId))
                {
                    throw new NotImplementedException();
                }
                else
                {
                    assert.SkipProperty(m => m.ContentTypeBeginsWithId, "ContentTypeBeginsWithId is null or empty, skipping.");
                }

                // mappings
                if (!string.IsNullOrEmpty(typedDefinition.DataMappings))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.DataMappings);
                        var isValid = false;

                        isValid = s.DataMappings == CurrentWebPartXml.GetProperty("DataMappings");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.DataMappings, "DataMappings is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.DataMappingViewFields))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.DataMappingViewFields);
                        var isValid = false;

                        isValid = s.DataMappingViewFields == CurrentWebPartXml.GetProperty("DataMappingViewFields");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.DataMappingViewFields, "DataMappingViewFields is null or empty, skipping.");
                }

                // filter display values

                if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue1))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterDisplayValue1);
                        var isValid = false;

                        isValid = s.FilterDisplayValue1 == CurrentWebPartXml.GetProperty("FilterDisplayValue1");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterDisplayValue1, "FilterDisplayValue1 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue2))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterDisplayValue2);
                        var isValid = false;

                        isValid = s.FilterDisplayValue2 == CurrentWebPartXml.GetProperty("FilterDisplayValue2");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterDisplayValue2, "FilterDisplayValue2 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue3))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterDisplayValue3);
                        var isValid = false;

                        isValid = s.FilterDisplayValue3 == CurrentWebPartXml.GetProperty("FilterDisplayValue3");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterDisplayValue3, "FilterDisplayValue3 is null or empty, skipping.");
                }

                // filter operator

                if (!string.IsNullOrEmpty(typedDefinition.FilterOperator1))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterOperator1);
                        var isValid = false;

                        isValid = s.FilterOperator1 == CurrentWebPartXml.GetProperty("FilterOperator1");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterOperator1, "FilterOperator1 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterOperator2))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterOperator2);
                        var isValid = false;

                        isValid = s.FilterOperator2 == CurrentWebPartXml.GetProperty("FilterOperator2");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterOperator2, "FilterOperator2 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterOperator3))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterOperator3);
                        var isValid = false;

                        isValid = s.FilterOperator3 == CurrentWebPartXml.GetProperty("FilterOperator3");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterOperator3, "FilterOperator3 is null or empty, skipping.");
                }

                // filter types

                if (!string.IsNullOrEmpty(typedDefinition.FilterType1))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterType1);
                        var isValid = false;

                        isValid = s.FilterType1 == CurrentWebPartXml.GetProperty("FilterType1");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterType1, "FilterType1 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterType2))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterType2);
                        var isValid = false;

                        isValid = s.FilterType2 == CurrentWebPartXml.GetProperty("FilterType2");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterType2, "FilterType2 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterType3))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterType3);
                        var isValid = false;

                        isValid = s.FilterType3 == CurrentWebPartXml.GetProperty("FilterType3");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterType3, "FilterType3 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.SortBy))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.SortBy);
                        var isValid = false;

                        isValid = s.SortBy == CurrentWebPartXml.GetProperty("SortBy");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.SortBy, "SortBy is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.SortByFieldType))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.SortByFieldType);
                        var isValid = false;

                        isValid = s.SortByFieldType == CurrentWebPartXml.GetProperty("SortByFieldType");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.SortByFieldType, "SortByFieldType is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.SortByDirection))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.SortByDirection);
                        var isValid = false;

                        isValid = s.SortByDirection == CurrentWebPartXml.GetProperty("SortByDirection");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.SortByDirection, "SortByDirection is null or empty, skipping.");
                }

                // filter values

                if (!string.IsNullOrEmpty(typedDefinition.FilterValue1))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterValue1);
                        var isValid = false;

                        isValid = s.FilterValue1 == CurrentWebPartXml.GetProperty("FilterValue1");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterValue1, "FilterValue1 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterValue2))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterValue2);
                        var isValid = false;

                        isValid = s.FilterValue2 == CurrentWebPartXml.GetProperty("FilterValue2");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterValue2, "FilterValue2 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterValue3))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterValue3);
                        var isValid = false;

                        isValid = s.FilterValue3 == CurrentWebPartXml.GetProperty("FilterValue3");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterValue3, "FilterValue3 is null or empty, skipping.");
                }

                // styles

                if (!string.IsNullOrEmpty(typedDefinition.GroupStyle))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.GroupStyle);
                        var isValid = false;

                        isValid = s.GroupStyle == CurrentWebPartXml.GetGroupStyle();

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.GroupStyle, "GroupStyle is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.ItemStyle))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ItemStyle);
                        var isValid = false;

                        isValid = s.ItemStyle == CurrentWebPartXml.GetItemStyle();

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ItemStyle, "ItemStyle is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.ItemXslLink))
                {
                    throw new NotImplementedException();
                }
                else
                {
                    assert.SkipProperty(m => m.ItemXslLink, "ItemXslLink is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.MainXslLink))
                {
                    throw new NotImplementedException();
                }
                else
                {
                    assert.SkipProperty(m => m.MainXslLink, "MainXslLink is null or empty, skipping.");
                }

                // list bindings

                if (!string.IsNullOrEmpty(typedDefinition.WebUrl))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.WebUrl);
                        var isValid = false;

                        isValid = s.WebUrl == CurrentWebPartXml.GetWebUrl();

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.WebUrl, "WebUrl is null or empty, skipping.");
                }

                if (typedDefinition.WebId.HasValue)
                {
                    throw new NotImplementedException();
                }
                else
                {
                    assert.SkipProperty(m => m.WebId, "WebId is null or empty, skipping.");
                }

                if (typedDefinition.ListGuid.HasGuidValue())
                {
                    throw new NotImplementedException();
                }
                else
                {
                    assert.SkipProperty(m => m.ListGuid, "ListGuid is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.ListName))
                {
                    throw new NotImplementedException();
                }
                else
                {
                    assert.SkipProperty(m => m.ListName, "ListName is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.ListUrl))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ListUrl);
                        var isValid = false;

                        // resolve web / url by list URL
                        // check ListId

                        var webLookup = new LookupFieldModelHandler();

                        var targetWeb = webLookup.GetTargetWeb(listItemModelHost.HostSite,
                                                               typedDefinition.WebUrl,
                                                               typedDefinition.WebId,
                                                               modelHost);

                        var list = targetWeb.QueryAndGetListByUrl(typedDefinition.ListUrl);
                        isValid  = CurrentWebPartXml.GetListGuid() == list.Id.ToString("D");

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ListUrl, "ListUrl is null or empty, skipping.");
                }

                // misc

                if (typedDefinition.ServerTemplate.HasValue)
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ServerTemplate);
                        var isValid = false;

                        isValid = ConvertUtils.ToInt(CurrentWebPartXml.GetProperty("ServerTemplate"))
                                  == typedDefinition.ServerTemplate;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ServerTemplate, "ServerTemplate is null or empty, skipping.");
                }

                if (typedDefinition.ItemLimit.HasValue)
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ItemLimit);
                        var isValid = false;

                        isValid = ConvertUtils.ToInt(CurrentWebPartXml.GetProperty("ItemLimit"))
                                  == typedDefinition.ItemLimit;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ItemLimit, "ItemLimit is null or empty, skipping.");
                }

                if (typedDefinition.PlayMediaInBrowser.HasValue)
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.PlayMediaInBrowser);
                        var isValid = false;

                        isValid = s.PlayMediaInBrowser == ConvertUtils.ToBool(CurrentWebPartXml.GetProperty("PlayMediaInBrowser"));

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.PlayMediaInBrowser, "PlayMediaInBrowser is null or empty, skipping.");
                }

                if (typedDefinition.ShowUntargetedItems.HasValue)
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ShowUntargetedItems);
                        var isValid = false;

                        isValid = s.ShowUntargetedItems == ConvertUtils.ToBool(CurrentWebPartXml.GetProperty("ShowUntargetedItems"));

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ShowUntargetedItems, "ShowUntargetedItems is null or empty, skipping.");
                }

                if (typedDefinition.UseCopyUtil.HasValue)
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.UseCopyUtil);
                        var isValid = false;

                        isValid = s.UseCopyUtil == ConvertUtils.ToBool(CurrentWebPartXml.GetProperty("UseCopyUtil"));

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.UseCopyUtil, "UseCopyUtil is null or empty, skipping.");
                }


                if (typedDefinition.DisplayColumns.HasValue)
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.DisplayColumns);
                        var isValid = false;

                        isValid = s.DisplayColumns == ConvertUtils.ToInt(CurrentWebPartXml.GetProperty("DisplayColumns"));

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.DisplayColumns, "DisplayColumns is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.GroupBy))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.GroupBy);
                        var isValid = false;

                        isValid = s.GroupBy == ConvertUtils.ToString(CurrentWebPartXml.GetProperty("GroupBy"));

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.GroupBy, "GroupBy is null or empty, skipping.");
                }
            });
        }
Пример #2
0
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            // base validation
            base.DeployModel(modelHost, model);


            // web specific validation
            var host       = modelHost.WithAssertAndCast <WebpartPageModelHost>("modelHost", value => value.RequireNotNull());
            var definition = model.WithAssertAndCast <XsltListViewWebPartDefinition>("model", value => value.RequireNotNull());

            //var item = host.PageListItem;

            WebPartExtensions.WithExistingWebPart(host.HostFile, definition, (spWebPartManager, spObject) =>
            {
                var web         = spWebPartManager.Web;
                var typedObject = spObject as XsltListViewWebPart;

                var assert = ServiceFactory.AssertService
                             .NewAssert(definition, typedObject)
                             .ShouldNotBeNull(typedObject);

                var typedDefinition = definition;
                var targetWeb       = web;

                // web url
                if (!string.IsNullOrEmpty(typedDefinition.WebUrl))
                {
                    var lookupFieldModelHandler = new LookupFieldModelHandler();
                    targetWeb = lookupFieldModelHandler.GetTargetWeb(web.Site,
                                                                     definition.WebUrl, definition.WebId);

                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.WebUrl);

                        var isValid = d.WebId == targetWeb.ID;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.WebUrl, "WebUrl is NULL. Skipping.");
                }

                if (typedDefinition.WebId.HasGuidValue())
                {
                    var lookupFieldModelHandler = new LookupFieldModelHandler();
                    targetWeb = lookupFieldModelHandler.GetTargetWeb(web.Site,
                                                                     definition.WebUrl, definition.WebId);

                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.WebId);

                        var isValid = d.WebId == targetWeb.ID;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.WebId, "WebId is NULL. Skipping.");
                }

                var targetList = web.Lists[typedObject.ListId];

                var hasList = !string.IsNullOrEmpty(definition.ListTitle) ||
                              !string.IsNullOrEmpty(definition.ListUrl) ||
                              definition.ListId.HasValue;
                var hasView = !string.IsNullOrEmpty(definition.ViewName) ||
                              definition.ViewId.HasValue;;

                if (definition.CacheXslStorage.HasValue)
                {
                    assert.ShouldBeEqual(m => m.CacheXslStorage, o => o.CacheXslStorage);
                }
                else
                {
                    assert.SkipProperty(m => m.CacheXslStorage, "CacheXslStorage is null or empty.");
                }

                if (definition.CacheXslTimeOut.HasValue)
                {
                    assert.ShouldBeEqual(m => m.CacheXslTimeOut, o => o.CacheXslTimeOut);
                }
                else
                {
                    assert.SkipProperty(m => m.CacheXslTimeOut, "CacheXslTimeOut is null or empty.");
                }

                if (definition.ShowTimelineIfAvailable.HasValue)
                {
                    assert.ShouldBeEqual(m => m.ShowTimelineIfAvailable, o => o.ShowTimelineIfAvailable);
                }
                else
                {
                    assert.SkipProperty(m => m.ShowTimelineIfAvailable, "ShowTimelineIfAvailable is null or empty.");
                }

                // list
                if (!string.IsNullOrEmpty(definition.ListTitle))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ListTitle);
                        var dstProp = d.GetExpressionValue(o => o.ListId);

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = targetList.ID == (Guid)dstProp.Value
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ListTitle, "ListTitle is null or empty. Skipping.");
                }

                if (!string.IsNullOrEmpty(definition.ListUrl))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ListUrl);
                        var dstProp = d.GetExpressionValue(o => o.ListId);

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = targetList.ID == (Guid)dstProp.Value
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ListUrl, "ListUrl is null or empty. Skipping.");
                }

                if (definition.ListId.HasValue && definition.ListId != default(Guid))
                {
                    assert.ShouldBeEqual(m => m.ListId, o => o.ListId);
                }
                else
                {
                    assert.SkipProperty(m => m.ListId, "ListId is null or empty. Skipping.");
                }

                // view
                if (definition.ViewId.HasValue)
                {
                    // web part gonna have hidden view
                    // so validation is a bit tricky, done by other properties

                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcView = targetList.Views[s.ViewId.Value];
                        var dstView = typedObject.View;

                        var srcProp = s.GetExpressionValue(m => m.ViewId);
                        var dstProp = d.GetExpressionValue(o => o.View);

                        var isValid = srcView.ViewFields.Count == dstView.ViewFields.Count &&
                                      srcView.Query == dstView.Query;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ViewId, "ViewId is null or empty. Skipping.");
                }

                if (!string.IsNullOrEmpty(definition.ViewName))
                {
                    // web part gonna have hidden view
                    // so validation is a bit tricky, done by other properties

                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcView = targetList.Views[s.ViewName];
                        var dstView = typedObject.View;

                        var srcProp = s.GetExpressionValue(m => m.ViewName);
                        var dstProp = d.GetExpressionValue(o => o.View);

                        var isValid = srcView.ViewFields.Count == dstView.ViewFields.Count &&
                                      srcView.Query == dstView.Query;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ViewName, "ViewName is null or empty. Skipping.");
                }

                // JSLink
                if (!string.IsNullOrEmpty(definition.JSLink))
                {
                    assert.ShouldBeEqual(m => m.JSLink, o => o.JSLink);
                }
                else
                {
                    assert.SkipProperty(m => m.JSLink);
                }

                if (definition.InplaceSearchEnabled.HasValue)
                {
                    assert.ShouldBeEqual(m => m.InplaceSearchEnabled, o => o.InplaceSearchEnabled);
                }
                else
                {
                    assert.SkipProperty(m => m.InplaceSearchEnabled, "InplaceSearchEnabled is null or empty.");
                }

                if (definition.DisableSaveAsNewViewButton.HasValue)
                {
                    assert.ShouldBeEqual(m => m.DisableSaveAsNewViewButton, o => o.DisableSaveAsNewViewButton);
                }
                else
                {
                    assert.SkipProperty(m => m.DisableSaveAsNewViewButton, "DisableSaveAsNewViewButton is null or empty.");
                }

                if (definition.DisableColumnFiltering.HasValue)
                {
                    assert.ShouldBeEqual(m => m.DisableColumnFiltering, o => o.DisableColumnFiltering);
                }
                else
                {
                    assert.SkipProperty(m => m.DisableColumnFiltering, "DisableColumnFiltering is null or empty.");
                }

                if (definition.DisableViewSelectorMenu.HasValue)
                {
                    assert.ShouldBeEqual(m => m.DisableViewSelectorMenu, o => o.DisableViewSelectorMenu);
                }
                else
                {
                    assert.SkipProperty(m => m.DisableViewSelectorMenu, "DisableViewSelectorMenu is null or empty.");
                }

                // title link
                if (string.IsNullOrEmpty(definition.TitleUrl))
                {
                    // list?
                    if (hasView)
                    {
                        assert.ShouldBeEqual((p, s, d) =>
                        {
                            var srcProp = s.GetExpressionValue(m => m.TitleUrl);
                            var srcView = string.IsNullOrEmpty(s.ViewName) ?
                                          targetList.Views[s.ViewId.Value] :
                                          targetList.Views[s.ViewName];

                            return(new PropertyValidationResult
                            {
                                Tag = p.Tag,
                                Src = srcProp,
                                Dst = null,
                                IsValid = srcView.ServerRelativeUrl.StartsWith(typedObject.TitleUrl)
                            });
                        });
                    }
                    else if (hasList)
                    {
                        assert.ShouldBeEqual((p, s, d) =>
                        {
                            var srcProp = s.GetExpressionValue(m => m.TitleUrl);

                            return(new PropertyValidationResult
                            {
                                Tag = p.Tag,
                                Src = srcProp,
                                Dst = null,
                                IsValid = targetList.DefaultViewUrl.StartsWith(typedObject.TitleUrl)
                            });
                        });
                    }
                }
                else
                {
                    assert.ShouldBeEqual(m => m.TitleUrl, o => o.TitleUrl);
                }

                if (!string.IsNullOrEmpty(definition.XslLink))
                {
                    assert.ShouldBeEqual(m => m.XslLink, o => o.XslLink);
                }
                else
                {
                    assert.SkipProperty(m => m.XslLink);
                }

                if (!string.IsNullOrEmpty(definition.XmlDefinitionLink))
                {
                    assert.ShouldBeEqual(m => m.XmlDefinitionLink, o => o.XmlDefinitionLink);
                }
                else
                {
                    assert.SkipProperty(m => m.XmlDefinitionLink);
                }

                if (!string.IsNullOrEmpty(definition.GhostedXslLink))
                {
                    assert.ShouldBeEqual(m => m.GhostedXslLink, o => o.GhostedXslLink);
                }
                else
                {
                    assert.SkipProperty(m => m.GhostedXslLink);
                }

                if (!string.IsNullOrEmpty(definition.BaseXsltHashKey))
                {
                    assert.ShouldBeEqual(m => m.BaseXsltHashKey, o => o.BaseXsltHashKey);
                }
                else
                {
                    assert.SkipProperty(m => m.BaseXsltHashKey);
                }


                if (!string.IsNullOrEmpty(definition.XmlDefinition))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var value        = ConvertUtils.ToString(d.XmlDefinition);
                        var destXmlAttrs = XDocument.Parse(value).Root.Attributes();

                        var srcProp = s.GetExpressionValue(m => m.XmlDefinition);
                        var isValid = true;

                        var srcXmlAttrs = XDocument.Parse(definition.XmlDefinition).Root.Attributes();

                        foreach (var srcAttr in srcXmlAttrs)
                        {
                            var attrName  = srcAttr.Name;
                            var attrValue = srcAttr.Value;

                            isValid = destXmlAttrs.FirstOrDefault(a => a.Name == attrName)
                                      .Value == attrValue;

                            if (!isValid)
                            {
                                break;
                            }
                        }

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.XmlDefinition);
                }

                if (!string.IsNullOrEmpty(definition.Xsl))
                {
                    assert.ShouldBeEqual(m => m.Xsl, o => o.Xsl);
                }
                else
                {
                    assert.SkipProperty(m => m.Xsl);
                }

                // skip it, it will be part of the .Toolbar validation
                assert.SkipProperty(m => m.ToolbarShowAlways, "");

                if (!string.IsNullOrEmpty(definition.Toolbar))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var targetView    = (spObject as XsltListViewWebPart).View;
                        var htmlSchemaXml = XDocument.Parse(targetView.HtmlSchemaXml);

                        var useShowAlwaysValue =
                            (typedDefinition.Toolbar.ToUpper() == BuiltInToolbarType.Standard.ToUpper()) &&
                            typedDefinition.ToolbarShowAlways.HasValue &&
                            typedDefinition.ToolbarShowAlways.Value;

                        var toolbarNode = htmlSchemaXml.Root
                                          .Descendants("Toolbar")
                                          .FirstOrDefault();

                        // NONE? the node might not be there
                        if ((typedDefinition.Toolbar.ToUpper() == BuiltInToolbarType.None.ToUpper()) &&
                            (toolbarNode == null))
                        {
                            var srcProp = s.GetExpressionValue(m => m.Toolbar);

                            return(new PropertyValidationResult
                            {
                                Tag = p.Tag,
                                Src = srcProp,
                                Dst = null,
                                IsValid = true
                            });
                        }
                        else
                        {
                            var toolBarValue = toolbarNode.GetAttributeValue("Type");

                            var srcProp = s.GetExpressionValue(m => m.Toolbar);
                            var isValid = toolBarValue.ToUpper() == definition.Toolbar.ToUpper();

                            if (useShowAlwaysValue)
                            {
                                var showAlwaysValue = toolbarNode.GetAttributeValue("ShowAlways");
                                isValid             = isValid && (showAlwaysValue.ToUpper() == "TRUE");
                            }

                            return(new PropertyValidationResult
                            {
                                Tag = p.Tag,
                                Src = srcProp,
                                Dst = null,
                                IsValid = isValid
                            });
                        }
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.Toolbar);
                }
            });
        }
Пример #3
0
        protected override string GetWebpartXmlDefinition(ListItemModelHost listItemModelHost, WebPartDefinitionBase webPartModel)
        {
            var typedDefinition = webPartModel.WithAssertAndCast <ContentByQueryWebPartDefinition>("model", value => value.RequireNotNull());
            var wpXml           = WebpartXmlExtensions.LoadWebpartXmlDocument(this.ProcessCommonWebpartProperties(BuiltInWebPartTemplates.ContentByQueryWebPart, webPartModel));

            // reset SortBy initially
            // it is set to {8c06beca-0777-48f7-91c7-6da68bc07b69} initially
            //wpXml.SetOrUpdateProperty("SortBy", string.Empty);

            var context = listItemModelHost.HostClientContext;

            // xslt links
            if (!string.IsNullOrEmpty(typedDefinition.MainXslLink))
            {
                var linkValue = typedDefinition.MainXslLink;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original MainXslLink: [{0}]", linkValue);

                linkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
                {
                    Value   = linkValue,
                    Context = listItemModelHost
                }).Value;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced MainXslLink: [{0}]", linkValue);

                wpXml.SetOrUpdateProperty("MainXslLink", linkValue);
            }

            if (!string.IsNullOrEmpty(typedDefinition.ItemXslLink))
            {
                var linkValue = typedDefinition.ItemXslLink;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original ItemXslLink: [{0}]", linkValue);

                linkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
                {
                    Value   = linkValue,
                    Context = listItemModelHost
                }).Value;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced ItemXslLink: [{0}]", linkValue);

                wpXml.SetOrUpdateProperty("ItemXslLink", linkValue);
            }

            if (!string.IsNullOrEmpty(typedDefinition.HeaderXslLink))
            {
                var linkValue = typedDefinition.HeaderXslLink;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original HeaderXslLink: [{0}]", linkValue);

                linkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
                {
                    Value   = linkValue,
                    Context = listItemModelHost
                }).Value;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced HeaderXslLink: [{0}]", linkValue);

                wpXml.SetOrUpdateProperty("HeaderXslLink", linkValue);
            }

            // styles
            if (!string.IsNullOrEmpty(typedDefinition.ItemStyle))
            {
                wpXml.SetItemStyle(typedDefinition.ItemStyle);
            }

            if (!string.IsNullOrEmpty(typedDefinition.GroupStyle))
            {
                wpXml.SetGroupStyle(typedDefinition.GroupStyle);
            }


            // cache settings
            if (typedDefinition.UseCache.HasValue)
            {
                wpXml.SetUseCache(typedDefinition.UseCache.ToString());
            }

            if (typedDefinition.CacheXslStorage.HasValue)
            {
                wpXml.SetOrUpdateProperty("CacheXslStorage", typedDefinition.CacheXslStorage.ToString());
            }

            if (typedDefinition.CacheXslTimeOut.HasValue)
            {
                wpXml.SetOrUpdateProperty("CacheXslTimeOut", typedDefinition.CacheXslTimeOut.ToString());
            }

            // item limit
            if (typedDefinition.ItemLimit.HasValue)
            {
                wpXml.SetOrUpdateProperty("ItemLimit", typedDefinition.ItemLimit.ToString());
            }

            // mappings
            if (!string.IsNullOrEmpty(typedDefinition.DataMappings))
            {
                wpXml.SetOrUpdateProperty("DataMappings", typedDefinition.DataMappings);
            }

            if (!string.IsNullOrEmpty(typedDefinition.DataMappingViewFields))
            {
                wpXml.SetOrUpdateProperty("DataMappingViewFields", typedDefinition.DataMappingViewFields);
            }

            // misc
            if (typedDefinition.ShowUntargetedItems.HasValue)
            {
                wpXml.SetOrUpdateProperty("ShowUntargetedItems", typedDefinition.ShowUntargetedItems.ToString());
            }

            if (typedDefinition.PlayMediaInBrowser.HasValue)
            {
                wpXml.SetOrUpdateProperty("PlayMediaInBrowser", typedDefinition.PlayMediaInBrowser.ToString());
            }

            if (typedDefinition.UseCopyUtil.HasValue)
            {
                wpXml.SetOrUpdateProperty("UseCopyUtil", typedDefinition.UseCopyUtil.ToString());
            }

            // FilterTypeXXX
            if (!string.IsNullOrEmpty(typedDefinition.FilterType1))
            {
                wpXml.SetOrUpdateProperty("FilterType1", typedDefinition.FilterType1);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterType2))
            {
                wpXml.SetOrUpdateProperty("FilterType2", typedDefinition.FilterType2);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterType3))
            {
                wpXml.SetOrUpdateProperty("FilterType3", typedDefinition.FilterType3);
            }

            // FilterFieldXXX
            if (!string.IsNullOrEmpty(typedDefinition.FilterField1))
            {
                wpXml.SetOrUpdateProperty("FilterField1", typedDefinition.FilterField1);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterField2))
            {
                wpXml.SetOrUpdateProperty("FilterField2", typedDefinition.FilterField2);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterField3))
            {
                wpXml.SetOrUpdateProperty("FilterField3", typedDefinition.FilterField3);
            }

            // FilterXXXIsCustomValue
            if (typedDefinition.Filter1IsCustomValue.HasValue)
            {
                wpXml.SetOrUpdateProperty("Filter1IsCustomValue", typedDefinition.Filter1IsCustomValue.ToString());
            }

            if (typedDefinition.Filter2IsCustomValue.HasValue)
            {
                wpXml.SetOrUpdateProperty("Filter2IsCustomValue", typedDefinition.Filter2IsCustomValue.ToString());
            }

            if (typedDefinition.Filter3IsCustomValue.HasValue)
            {
                wpXml.SetOrUpdateProperty("Filter3IsCustomValue", typedDefinition.Filter3IsCustomValue.ToString());
            }

            // FilterValueXXX
            if (!string.IsNullOrEmpty(typedDefinition.FilterValue1))
            {
                wpXml.SetOrUpdateProperty("FilterValue1", typedDefinition.FilterValue1);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterValue2))
            {
                wpXml.SetOrUpdateProperty("FilterValue2", typedDefinition.FilterValue2);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterValue3))
            {
                wpXml.SetOrUpdateProperty("FilterValue3", typedDefinition.FilterValue3);
            }

            var filterChainingOperatorType = "Microsoft.SharePoint.Publishing.WebControls.ContentByQueryWebPart+FilterChainingOperator, Microsoft.SharePoint.Publishing, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c";

            if (!string.IsNullOrEmpty(typedDefinition.Filter1ChainingOperator))
            {
                wpXml.SetTypedProperty("Filter1ChainingOperator", typedDefinition.Filter1ChainingOperator, filterChainingOperatorType);
            }

            if (!string.IsNullOrEmpty(typedDefinition.Filter2ChainingOperator))
            {
                wpXml.SetTypedProperty("Filter2ChainingOperator", typedDefinition.Filter2ChainingOperator, filterChainingOperatorType);
            }


            // sorting
            if (!string.IsNullOrEmpty(typedDefinition.SortBy))
            {
                wpXml.SetOrUpdateProperty("SortBy", typedDefinition.SortBy);
            }

            if (!string.IsNullOrEmpty(typedDefinition.SortByDirection))
            {
                wpXml.SetTypedProperty("SortByDirection", typedDefinition.SortByDirection, "Microsoft.SharePoint.Publishing.WebControls.ContentByQueryWebPart+SortDirection, Microsoft.SharePoint.Publishing, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c");
            }

            if (!string.IsNullOrEmpty(typedDefinition.SortByFieldType))
            {
                wpXml.SetOrUpdateProperty("SortByFieldType", typedDefinition.SortByFieldType);
            }

            if (!string.IsNullOrEmpty(typedDefinition.GroupByDirection))
            {
                wpXml.SetTypedProperty("GroupByDirection", typedDefinition.GroupByDirection, "Microsoft.SharePoint.Publishing.WebControls.ContentByQueryWebPart+SortDirection, Microsoft.SharePoint.Publishing, Version=15.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c");
            }

            var filterOperatorType = "Microsoft.SharePoint.Publishing.WebControls.ContentByQueryWebPart+FilterFieldQueryOperator, Microsoft.SharePoint.Publishing, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c";


            // FilterOperatorXXX
            if (!string.IsNullOrEmpty(typedDefinition.FilterOperator1))
            {
                wpXml.SetTypedProperty("FilterOperator1", typedDefinition.FilterOperator1, filterOperatorType);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterOperator2))
            {
                wpXml.SetTypedProperty("FilterOperator2", typedDefinition.FilterOperator2, filterOperatorType);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterOperator3))
            {
                wpXml.SetTypedProperty("FilterOperator3", typedDefinition.FilterOperator3, filterOperatorType);
            }

            // FilterDisplayValueXXX

            if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue1))
            {
                wpXml.SetOrUpdateProperty("FilterDisplayValue1", typedDefinition.FilterDisplayValue1);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue2))
            {
                wpXml.SetOrUpdateProperty("FilterDisplayValue2", typedDefinition.FilterDisplayValue2);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue3))
            {
                wpXml.SetOrUpdateProperty("FilterDisplayValue3", typedDefinition.FilterDisplayValue3);
            }


            // bindings
            if (typedDefinition.ServerTemplate.HasValue)
            {
                wpXml.SetOrUpdateProperty("ServerTemplate", typedDefinition.ServerTemplate.ToString());
            }

            if (!string.IsNullOrEmpty(typedDefinition.ContentTypeName))
            {
                wpXml.SetOrUpdateProperty("ContentTypeName", typedDefinition.ContentTypeName);
            }

            if (!string.IsNullOrEmpty(typedDefinition.ContentTypeBeginsWithId))
            {
                wpXml.SetOrUpdateProperty("ContentTypeBeginsWithId", typedDefinition.ContentTypeBeginsWithId);
            }

            if (typedDefinition.ListId.HasGuidValue())
            {
                wpXml.SetTypedProperty("ListId", typedDefinition.ListId.Value.ToString("D"), "Microsoft.SharePoint.Publishing.WebControls.ContentByQueryWebPart+FilterChainingOperator, Microsoft.SharePoint.Publishing, Version=14.0.0.0, Culture=neutral, PublicKeyToken=71e9bce111e9429c");
            }

            if (typedDefinition.ListGuid.HasGuidValue())
            {
                wpXml.SetOrUpdateProperty("ListGuid", typedDefinition.ListGuid.Value.ToString("D"));
            }

            if (!string.IsNullOrEmpty(typedDefinition.ListName))
            {
                // ServerTemplate

                var webLookup = new LookupFieldModelHandler();

                var targetWeb = webLookup.GetTargetWeb(listItemModelHost.HostSite,
                                                       typedDefinition.WebUrl,
                                                       typedDefinition.WebId);

                var list = targetWeb.QueryAndGetListByTitle(typedDefinition.ListName);
                wpXml.SetOrUpdateProperty("ListGuid", list.Id.ToString("D"));

#if !NET35
                var folder = list.RootFolder;

                context.Load(folder, f => f.Properties);
                context.ExecuteQueryWithTrace();

                var serverTemplate = ConvertUtils.ToString(list.RootFolder.Properties["vti_listservertemplate"]);

                if (string.IsNullOrEmpty(serverTemplate))
                {
                    throw new SPMeta2Exception(
                              string.Format("Cannot find vti_listservertemplate property for the list name:[{0}]",
                                            typedDefinition.ListName));
                }

                wpXml.SetOrUpdateProperty("ServerTemplate", serverTemplate);
#endif
            }

            if (!string.IsNullOrEmpty(typedDefinition.ListUrl))
            {
                var webLookup = new LookupFieldModelHandler();

                var targetWeb = webLookup.GetTargetWeb(listItemModelHost.HostSite,
                                                       typedDefinition.WebUrl,
                                                       typedDefinition.WebId);

                var list = targetWeb.QueryAndGetListByUrl(typedDefinition.ListUrl);
                wpXml.SetOrUpdateProperty("ListGuid", list.Id.ToString("D"));

#if !NET35
                var folder = list.RootFolder;

                context.Load(folder, f => f.Properties);
                context.ExecuteQueryWithTrace();

                var serverTemplate = ConvertUtils.ToString(list.RootFolder.Properties["vti_listservertemplate"]);

                if (string.IsNullOrEmpty(serverTemplate))
                {
                    throw new SPMeta2Exception(
                              string.Format("Cannot find vti_listservertemplate property for the list url:[{0}]",
                                            typedDefinition.ListUrl));
                }

                wpXml.SetOrUpdateProperty("ServerTemplate", serverTemplate);
#endif
            }

            if (!string.IsNullOrEmpty(typedDefinition.WebUrl))
            {
                wpXml.SetOrUpdateProperty("WebUrl", typedDefinition.WebUrl);
            }

            // overrides
            if (!string.IsNullOrEmpty(typedDefinition.ListsOverride))
            {
                wpXml.SetOrUpdateProperty("ListsOverride", typedDefinition.ListsOverride);
            }

            if (!string.IsNullOrEmpty(typedDefinition.ViewFieldsOverride))
            {
                wpXml.SetOrUpdateProperty("ViewFieldsOverride", typedDefinition.ViewFieldsOverride);
            }

            if (!string.IsNullOrEmpty(typedDefinition.QueryOverride))
            {
                wpXml.SetOrUpdateProperty("QueryOverride", typedDefinition.QueryOverride);
            }

            if (!string.IsNullOrEmpty(typedDefinition.CommonViewFields))
            {
                wpXml.SetOrUpdateProperty("CommonViewFields", typedDefinition.CommonViewFields);
            }

            if (typedDefinition.FilterByAudience.HasValue)
            {
                wpXml.SetOrUpdateProperty("FilterByAudience", typedDefinition.FilterByAudience.ToString());
            }

            // misc
            if (!string.IsNullOrEmpty(typedDefinition.GroupBy))
            {
                wpXml.SetOrUpdateProperty("GroupBy", typedDefinition.GroupBy);
            }

            if (typedDefinition.DisplayColumns.HasValue)
            {
                wpXml.SetOrUpdateProperty("DisplayColumns", typedDefinition.DisplayColumns.ToString());
            }

            return(wpXml.ToString());
        }
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            ModelHost = modelHost;

            var definition = model.WithAssertAndCast <FieldDefinition>("model", value => value.RequireNotNull());
            var spObject   = GetField(modelHost, definition);

            var assert = ServiceFactory.AssertService.NewAssert(model, definition, spObject);

            ValidateField(assert, spObject, definition);

            var typedField      = spObject as SPFieldLookup;
            var typedDefinition = model.WithAssertAndCast <LookupFieldDefinition>("model", value => value.RequireNotNull());

            var typedFieldAssert = ServiceFactory.AssertService.NewAssert(model, typedDefinition, typedField);

            typedFieldAssert.ShouldBeEqual(m => m.AllowMultipleValues, o => o.AllowMultipleValues);

            if (typedDefinition.LookupWebId.HasValue)
            {
                typedFieldAssert.ShouldBeEqual(m => m.LookupWebId, o => o.LookupWebId);
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupWebId, "LookupWebId is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.RelationshipDeleteBehavior))
            {
                typedFieldAssert.ShouldBeEqual(m => m.RelationshipDeleteBehavior, o => o.GetRelationshipDeleteBehavior());
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.RelationshipDeleteBehavior, "RelationshipDeleteBehavior is NULL. Skipping.");
            }

            // web url
            if (!string.IsNullOrEmpty(typedDefinition.LookupWebUrl))
            {
                var lookupFieldModelHandler = new LookupFieldModelHandler();
                var targetWeb = lookupFieldModelHandler.GetTargetWeb(GetCurrentSite(), typedDefinition);

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupWebUrl);

                    var isValid = d.LookupWebId == targetWeb.ID;

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupWebUrl, "LookupWebUrl is NULL. Skipping.");
            }


            if (!string.IsNullOrEmpty(typedDefinition.LookupListTitle))
            {
                var lookupFieldModelHandler = new LookupFieldModelHandler();

                var targetWeb = lookupFieldModelHandler.GetTargetWeb(GetCurrentSite(), typedDefinition);
                var list      = targetWeb.Lists[typedDefinition.LookupListTitle];

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupListTitle);

                    var isValid = list.ID == new Guid(typedField.LookupList);

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupListTitle, "LookupListTitle is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupListUrl))
            {
                var lookupFieldModelHandler = new LookupFieldModelHandler();

                var targetWeb = lookupFieldModelHandler.GetTargetWeb(GetCurrentSite(), typedDefinition);
                var list      = targetWeb.GetList(SPUrlUtility.CombineUrl(targetWeb.ServerRelativeUrl, typedDefinition.LookupListUrl));

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupListUrl);

                    var isValid = list.ID == new Guid(typedField.LookupList);

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupListUrl, "LookupListUrl is NULL. Skipping.");
            }


            if (!string.IsNullOrEmpty(typedDefinition.LookupList))
            {
                if (typedDefinition.LookupList.ToUpper() == "USERINFO")
                {
                    typedFieldAssert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.LookupList);

                        var isValid = GetCurrentSite().RootWeb.SiteUserInfoList.ID == new Guid(typedField.LookupList);

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    typedFieldAssert.ShouldBeEqual(m => m.LookupList, o => o.LookupList);
                }
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupList, "LookupList is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupField))
            {
                typedFieldAssert.ShouldBeEqual(m => m.LookupField, o => o.LookupField);
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupField, "LookupField is NULL. Skipping.");
            }
        }
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            var definition = model.WithAssertAndCast <FieldDefinition>("model", value => value.RequireNotNull());
            var spObject   = GetField(modelHost, definition);

            HostList = ExtractListFromHost(modelHost);
            HostSite = ExtractSiteFromHost(modelHost);

            CurrentModelHost = modelHost.WithAssertAndCast <CSOMModelHostBase>("CurrentModelHost", value => value.RequireNotNull());

            var assert = ServiceFactory.AssertService.NewAssert(model, definition, spObject);

            ValidateField(assert, spObject, definition);

            var typedField      = spObject.Context.CastTo <FieldLookup>(spObject);
            var typedDefinition = model.WithAssertAndCast <LookupFieldDefinition>("model", value => value.RequireNotNull());

            var typedFieldAssert = ServiceFactory.AssertService.NewAssert(model, typedDefinition, typedField);

            if (SkipAllowMultipleValuesValidation)
            {
                // CSOM provision for DependentLookupFieldDefinition does not update AllowMultipleValues
                // seems to be a by design SharePoint issue
                // https://github.com/SubPointSolutions/spmeta2/issues/753

                typedFieldAssert.SkipProperty(m => m.AllowMultipleValues, "Skipping. SkipAllowMultipleValuesValidation = true");
            }
            else
            {
                typedFieldAssert.ShouldBeEqual(m => m.AllowMultipleValues, o => o.AllowMultipleValues);
            }

            if (typedDefinition.LookupWebId.HasValue)
            {
                typedFieldAssert.ShouldBeEqual(m => m.LookupWebId, o => o.LookupWebId);
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupWebId, "LookupWebId is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupWebUrl))
            {
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupWebUrl, "LookupWebUrl is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.RelationshipDeleteBehavior))
            {
                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.RelationshipDeleteBehavior);
                    var isValid = s.RelationshipDeleteBehavior == d.RelationshipDeleteBehavior.ToString();

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.RelationshipDeleteBehavior, "RelationshipDeleteBehavior is NULL. Skipping.");
            }

            // web url
            if (!string.IsNullOrEmpty(typedDefinition.LookupWebUrl))
            {
                var lookupFieldModelHandler = new LookupFieldModelHandler();
                ReflectionUtils.SetNonPublicPropertyValue(lookupFieldModelHandler, "CurrentModelHost", CurrentModelHost);
                ReflectionUtils.SetNonPublicPropertyValue(lookupFieldModelHandler, "ModelHost", CurrentModelHost);

                var targetWeb = lookupFieldModelHandler.GetTargetWeb(HostSite, typedDefinition);

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupWebUrl);

                    var isValid = d.LookupWebId == targetWeb.Id;

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupWebUrl, "LookupWebUrl is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupListTitle))
            {
                var site    = HostSite;
                var context = site.Context;

                var lookupFieldModelHandler = new LookupFieldModelHandler();
                ReflectionUtils.SetNonPublicPropertyValue(lookupFieldModelHandler, "CurrentModelHost", CurrentModelHost);
                ReflectionUtils.SetNonPublicPropertyValue(lookupFieldModelHandler, "ModelHost", CurrentModelHost);

                var web = lookupFieldModelHandler.GetTargetWeb(site, typedDefinition);

                context.Load(web);
                context.ExecuteQueryWithTrace();

                var list = web.Lists.GetByTitle(typedDefinition.LookupListTitle);

                context.Load(list);
                context.ExecuteQueryWithTrace();

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupListTitle);

                    var isValid = list.Id == new Guid(typedField.LookupList);

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupListTitle, "LookupListTitle is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupListUrl))
            {
                var site    = HostSite;
                var context = site.Context;

                var lookupFieldModelHandler = new LookupFieldModelHandler();
                ReflectionUtils.SetNonPublicPropertyValue(lookupFieldModelHandler, "CurrentModelHost", CurrentModelHost);
                ReflectionUtils.SetNonPublicPropertyValue(lookupFieldModelHandler, "ModelHost", CurrentModelHost);

                var web = lookupFieldModelHandler.GetTargetWeb(site, typedDefinition);

                context.Load(web);
                context.ExecuteQueryWithTrace();

                var list = web.QueryAndGetListByUrl(UrlUtility.CombineUrl(web.ServerRelativeUrl, typedDefinition.LookupListUrl));

                context.Load(list);
                context.ExecuteQueryWithTrace();

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupListUrl);

                    var isValid = list.Id == new Guid(typedField.LookupList);

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupListUrl, "LookupListUrl is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupList))
            {
                if (typedDefinition.LookupList.ToUpper() == "USERINFO")
                {
                    typedFieldAssert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.LookupList);

                        var site    = HostSite;
                        var context = site.Context;

                        var userInfoList = site.RootWeb.SiteUserInfoList;
                        context.Load(userInfoList);
                        context.ExecuteQueryWithTrace();

                        var isValid = userInfoList.Id == new Guid(typedField.LookupList);

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    typedFieldAssert.ShouldBeEqual(m => m.LookupList, o => o.LookupList);
                }
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupList, "LookupList is NULL. Skipping.");
            }

            if (SkipLookupFieldValidation)
            {
                // CSOM provision for DependentLookupFieldDefinition does not update LookupField
                // seems to be a by design SharePoint issue
                // https://github.com/SubPointSolutions/spmeta2/issues/753

                typedFieldAssert.SkipProperty(m => m.LookupField, "Skipping. SkipLookupFieldValidation = true");
            }
            else
            {
                if (!string.IsNullOrEmpty(typedDefinition.LookupField))
                {
                    typedFieldAssert.ShouldBeEqual(m => m.LookupField, o => o.LookupField);
                }
                else
                {
                    typedFieldAssert.SkipProperty(m => m.LookupField, "LookupField is NULL. Skipping.");
                }
            }

            if (typedDefinition.CountRelated.HasValue)
            {
                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp    = s.GetExpressionValue(m => m.CountRelated);
                    var dstXmlNode = XDocument.Parse(d.SchemaXml).Root;

                    var isValid = bool.Parse(dstXmlNode.Attribute("CountRelated").Value) ==
                                  typedDefinition.CountRelated.Value;

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });

                //typedFieldAssert.ShouldBeEqual(m => m.CountRelated, o => o.cou);
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.CountRelated, "CountRelated is NULL. Skipping.");
            }
        }
Пример #6
0
        protected override void ProcessWebpartProperties(WebPart webpartInstance, WebPartDefinition definition)
        {
            base.ProcessWebpartProperties(webpartInstance, definition);

            var typedWebpart    = webpartInstance.WithAssertAndCast <ContentByQueryWebPart>("webpartInstance", value => value.RequireNotNull());
            var typedDefinition = definition.WithAssertAndCast <ContentByQueryWebPartDefinition>("webpartModel", value => value.RequireNotNull());

            // xslt links
            if (!string.IsNullOrEmpty(typedDefinition.MainXslLink))
            {
                var linkValue = typedDefinition.MainXslLink;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original MainXslLink: [{0}]", linkValue);

                linkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
                {
                    Value   = linkValue,
                    Context = CurrentHost.HostFile.Web
                }).Value;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced MainXslLink: [{0}]", linkValue);

                typedWebpart.MainXslLink = linkValue;
            }

            if (!string.IsNullOrEmpty(typedDefinition.ItemXslLink))
            {
                var linkValue = typedDefinition.ItemXslLink;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original ItemXslLink: [{0}]", linkValue);

                linkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
                {
                    Value   = linkValue,
                    Context = CurrentHost.HostFile.Web
                }).Value;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced ItemXslLink: [{0}]", linkValue);

                typedWebpart.ItemXslLink = linkValue;
            }

            if (!string.IsNullOrEmpty(typedDefinition.HeaderXslLink))
            {
                var linkValue = typedDefinition.HeaderXslLink;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Original HeaderXslLink: [{0}]", linkValue);

                linkValue = TokenReplacementService.ReplaceTokens(new TokenReplacementContext
                {
                    Value   = linkValue,
                    Context = CurrentHost.HostFile.Web
                }).Value;

                TraceService.VerboseFormat((int)LogEventId.ModelProvisionCoreCall, "Token replaced HeaderXslLink: [{0}]", linkValue);

                typedWebpart.HeaderXslLink = linkValue;
            }

            // styles
            if (!string.IsNullOrEmpty(typedDefinition.ItemStyle))
            {
                typedWebpart.ItemStyle = typedDefinition.ItemStyle;
            }

            if (!string.IsNullOrEmpty(typedDefinition.GroupStyle))
            {
                typedWebpart.GroupStyle = typedDefinition.GroupStyle;
            }


            // cache settings
            if (typedDefinition.UseCache.HasValue)
            {
                typedWebpart.UseCache = typedDefinition.UseCache.Value;
            }

            if (typedDefinition.CacheXslStorage.HasValue)
            {
                typedWebpart.CacheXslStorage = typedDefinition.CacheXslStorage.Value;
            }

            if (typedDefinition.CacheXslTimeOut.HasValue)
            {
                typedWebpart.CacheXslTimeOut = typedDefinition.CacheXslTimeOut.Value;
            }

            // item limit
            if (typedDefinition.ItemLimit.HasValue)
            {
                typedWebpart.ItemLimit = typedDefinition.ItemLimit.Value;
            }

            // mappings
            if (!string.IsNullOrEmpty(typedDefinition.DataMappings))
            {
                typedWebpart.DataMappings = typedDefinition.DataMappings;
            }

            if (!string.IsNullOrEmpty(typedDefinition.DataMappingViewFields))
            {
                typedWebpart.DataMappingViewFields = typedDefinition.DataMappingViewFields;
            }

            // misc
            if (typedDefinition.ShowUntargetedItems.HasValue)
            {
                typedWebpart.ShowUntargetedItems = typedDefinition.ShowUntargetedItems.Value;
            }

            if (typedDefinition.PlayMediaInBrowser.HasValue)
            {
                typedWebpart.PlayMediaInBrowser = typedDefinition.PlayMediaInBrowser.Value;
            }

            if (typedDefinition.UseCopyUtil.HasValue)
            {
                typedWebpart.UseCopyUtil = typedDefinition.UseCopyUtil.Value;
            }

            // FilterTypeXXX
            if (!string.IsNullOrEmpty(typedDefinition.FilterType1))
            {
                typedWebpart.FilterType1 = typedDefinition.FilterType1;
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterType2))
            {
                typedWebpart.FilterType2 = typedDefinition.FilterType2;
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterType3))
            {
                typedWebpart.FilterType3 = typedDefinition.FilterType3;
            }

            // FilterFieldXXX
            if (!string.IsNullOrEmpty(typedDefinition.FilterField1))
            {
                typedWebpart.FilterField1 = typedDefinition.FilterField1;
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterField2))
            {
                typedWebpart.FilterField2 = typedDefinition.FilterField2;
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterField3))
            {
                typedWebpart.FilterField3 = typedDefinition.FilterField3;
            }

            // FilterXXXIsCustomValue
            if (typedDefinition.Filter1IsCustomValue.HasValue)
            {
                typedWebpart.Filter1IsCustomValue = typedDefinition.Filter1IsCustomValue.Value;
            }

            if (typedDefinition.Filter2IsCustomValue.HasValue)
            {
                typedWebpart.Filter2IsCustomValue = typedDefinition.Filter2IsCustomValue.Value;
            }

            if (typedDefinition.Filter3IsCustomValue.HasValue)
            {
                typedWebpart.Filter3IsCustomValue = typedDefinition.Filter3IsCustomValue.Value;
            }

            // FilterValueXXX
            if (!string.IsNullOrEmpty(typedDefinition.FilterValue1))
            {
                typedWebpart.FilterValue1 = typedDefinition.FilterValue1;
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterValue2))
            {
                typedWebpart.FilterValue2 = typedDefinition.FilterValue2;
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterValue3))
            {
                typedWebpart.FilterValue3 = typedDefinition.FilterValue3;
            }


            if (!string.IsNullOrEmpty(typedDefinition.Filter1ChainingOperator))
            {
                typedWebpart.Filter1ChainingOperator = (ContentByQueryWebPart.FilterChainingOperator)
                                                       Enum.Parse(typeof(ContentByQueryWebPart.FilterChainingOperator), typedDefinition.Filter1ChainingOperator);
            }

            if (!string.IsNullOrEmpty(typedDefinition.Filter2ChainingOperator))
            {
                typedWebpart.Filter2ChainingOperator = (ContentByQueryWebPart.FilterChainingOperator)
                                                       Enum.Parse(typeof(ContentByQueryWebPart.FilterChainingOperator), typedDefinition.Filter2ChainingOperator);
            }


            // sorting
            if (!string.IsNullOrEmpty(typedDefinition.SortBy))
            {
                typedWebpart.SortBy = typedDefinition.SortBy;
            }

            if (!string.IsNullOrEmpty(typedDefinition.SortByDirection))
            {
                typedWebpart.SortByDirection = (ContentByQueryWebPart.SortDirection)
                                               Enum.Parse(typeof(ContentByQueryWebPart.SortDirection), typedDefinition.SortByDirection);
            }

            if (!string.IsNullOrEmpty(typedDefinition.SortByFieldType))
            {
                typedWebpart.SortByFieldType = typedDefinition.SortByFieldType;
            }

            if (!string.IsNullOrEmpty(typedDefinition.GroupByDirection))
            {
                typedWebpart.GroupByDirection = (ContentByQueryWebPart.SortDirection)
                                                Enum.Parse(typeof(ContentByQueryWebPart.SortDirection), typedDefinition.GroupByDirection);
            }


            // FilterOperatorXXX
            if (!string.IsNullOrEmpty(typedDefinition.FilterOperator1))
            {
                typedWebpart.FilterOperator1 = (ContentByQueryWebPart.FilterFieldQueryOperator)
                                               Enum.Parse(typeof(ContentByQueryWebPart.FilterFieldQueryOperator), typedDefinition.FilterOperator1);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterOperator2))
            {
                typedWebpart.FilterOperator2 = (ContentByQueryWebPart.FilterFieldQueryOperator)
                                               Enum.Parse(typeof(ContentByQueryWebPart.FilterFieldQueryOperator), typedDefinition.FilterOperator2);
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterOperator3))
            {
                typedWebpart.FilterOperator3 = (ContentByQueryWebPart.FilterFieldQueryOperator)
                                               Enum.Parse(typeof(ContentByQueryWebPart.FilterFieldQueryOperator), typedDefinition.FilterOperator3);
            }

            // FilterDisplayValueXXX

            if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue1))
            {
                typedWebpart.FilterDisplayValue1 = typedDefinition.FilterDisplayValue1;
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue2))
            {
                typedWebpart.FilterDisplayValue2 = typedDefinition.FilterDisplayValue2;
            }

            if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue3))
            {
                typedWebpart.FilterDisplayValue3 = typedDefinition.FilterDisplayValue3;
            }


            // bindings
            if (typedDefinition.ServerTemplate.HasValue)
            {
                typedWebpart.ServerTemplate = typedDefinition.ServerTemplate.ToString();
            }

            if (!string.IsNullOrEmpty(typedDefinition.ContentTypeName))
            {
                typedWebpart.ContentTypeName = typedDefinition.ContentTypeName;
            }

            if (!string.IsNullOrEmpty(typedDefinition.ContentTypeBeginsWithId))
            {
                typedWebpart.ContentTypeBeginsWithId = typedDefinition.ContentTypeBeginsWithId;
            }


            if (!string.IsNullOrEmpty(typedDefinition.WebUrl))
            {
                // go with OOTB one, no changes are required

                //var webLookup = new LookupFieldModelHandler();

                //using (var targetWeb = webLookup.GetTargetWeb(CurrentHost.HostFile.Web.Site,
                //    typedDefinition.WebUrl,
                //    typedDefinition.WebId))
                //{
                //    typedWebpart.WebUrl = targetWeb.ServerRelativeUrl;
                //}

                typedWebpart.WebUrl = typedDefinition.WebUrl;
            }

            #region list URL

            if (typedDefinition.ListId.HasGuidValue())
            {
                //typedWebpart.ListId = typedDefinition.ListId.Value;
                // fallback to ListGuid

                typedWebpart.ListGuid = typedDefinition.ListId.Value.ToString("D");
            }

            if (typedDefinition.ListGuid.HasGuidValue())
            {
                typedWebpart.ListGuid = typedDefinition.ListGuid.Value.ToString("D");
            }

            if (!string.IsNullOrEmpty(typedDefinition.ListName))
            {
                // lookup from the target web
                // fallback to ListGuid

                var webLookup = new LookupFieldModelHandler();

                using (var targetWeb = webLookup.GetTargetWeb(CurrentHost.HostFile.Web.Site,
                                                              typedDefinition.WebUrl,
                                                              typedDefinition.WebId))
                {
                    var list = targetWeb.Lists[typedDefinition.ListName];
                    typedWebpart.ListGuid = list.ID.ToString("D");
                }
            }

            if (!string.IsNullOrEmpty(typedDefinition.ListUrl))
            {
                // lookup from the target web
                // fallback to ListGuid

                var webLookup = new LookupFieldModelHandler();

                using (var targetWeb = webLookup.GetTargetWeb(CurrentHost.HostFile.Web.Site,
                                                              typedDefinition.WebUrl,
                                                              typedDefinition.WebId))
                {
                    var listUrl = SPUrlUtility.CombineUrl(targetWeb.ServerRelativeUrl, typedDefinition.ListUrl);
                    var list    = targetWeb.GetList(listUrl);

                    typedWebpart.ListGuid = list.ID.ToString("D");
                }
            }

            #endregion

            // overrides
            if (!string.IsNullOrEmpty(typedDefinition.ListsOverride))
            {
                typedWebpart.ListsOverride = typedDefinition.ListsOverride;
            }

            if (!string.IsNullOrEmpty(typedDefinition.ViewFieldsOverride))
            {
                typedWebpart.ViewFieldsOverride = typedDefinition.ViewFieldsOverride;
            }

            if (!string.IsNullOrEmpty(typedDefinition.QueryOverride))
            {
                typedWebpart.QueryOverride = typedDefinition.QueryOverride;
            }

            if (!string.IsNullOrEmpty(typedDefinition.CommonViewFields))
            {
                typedWebpart.CommonViewFields = typedDefinition.CommonViewFields;
            }

            if (typedDefinition.FilterByAudience.HasValue)
            {
                typedWebpart.FilterByAudience = typedDefinition.FilterByAudience.Value;
            }

            // misc
            if (!string.IsNullOrEmpty(typedDefinition.GroupBy))
            {
                typedWebpart.GroupBy = typedDefinition.GroupBy;
            }

            if (typedDefinition.DisplayColumns.HasValue)
            {
                typedWebpart.DisplayColumns = typedDefinition.DisplayColumns.Value;
            }
        }
        internal static ListBindContext LookupBindContext(ListItemModelHost listItemModelHost,
                                                          string webUrl, Guid?webId,
                                                          string listUrl, string listTitle, Guid?listId,
                                                          string viewUrl, string viewTitle, Guid?viewId,
                                                          string webPartTitleUrl
                                                          )
        {
            var result = new ListBindContext
            {
            };

            var web     = listItemModelHost.HostWeb;
            var context = listItemModelHost.HostWeb.Context;

            var targetWeb = listItemModelHost.HostWeb;

            if (webId.HasGuidValue() || !string.IsNullOrEmpty(webUrl))
            {
                var lookupFieldModelHandler = new LookupFieldModelHandler();

                targetWeb = lookupFieldModelHandler
                            .GetTargetWeb(
                    listItemModelHost.HostClientContext.Site,
                    webUrl,
                    webId,
                    listItemModelHost);

                result.WebId = targetWeb.Id;
            }

            var list = LookupList(targetWeb, listUrl, listTitle, listId);

            View view = null;

            if (viewId.HasValue && viewId != default(Guid))
            {
                view = list.Views.GetById(viewId.Value);
            }
            else if (!string.IsNullOrEmpty(viewTitle))
            {
                view = list.Views.GetByTitle(viewTitle);
            }
            else if (!string.IsNullOrEmpty(viewUrl))
            {
                var views = list.Views;

                context.Load(views, v => v.Include(r => r.ServerRelativeUrl));
                context.ExecuteQueryWithTrace();

                view = views.ToArray()
                       .FirstOrDefault(v => v.ServerRelativeUrl.ToUpper().EndsWith(viewUrl.ToUpper()));
            }

            context.Load(list, l => l.Id);
            context.Load(list, l => l.DefaultViewUrl);
            context.Load(list, l => l.Title);

            // TODO, https://github.com/SubPointSolutions/spmeta2/issues/765
            // list.DefaultView is not available, so a full fetch for list view is a must for SP2010.

#if !NET35
            context.Load(list, l => l.DefaultView);
#endif

            if (view != null)
            {
                context.Load(view);
                context.ExecuteQueryWithTrace();

#if !NET35
                result.OriginalView   = list.DefaultView;
                result.OriginalViewId = list.DefaultView.Id;
#endif

                result.TargetView   = view;
                result.TargetViewId = view.Id;

                result.TitleUrl = view.ServerRelativeUrl;
            }
            else
            {
                context.ExecuteQueryWithTrace();
            }

            result.ListId = list.Id;
            result.List   = list;


            result.List = list;

            if (webPartTitleUrl == null)
            {
                if (string.IsNullOrEmpty(result.TitleUrl))
                {
                    result.TitleUrl = list.DefaultViewUrl;
                }
            }

#if !NET35
            result.DefaultViewId = list.DefaultView.Id;
#endif

            return(result);
        }
        protected override void InternalOnAfterWebPartProvision(WebPartProcessingContext provisionContext)
        {
            base.InternalOnAfterWebPartProvision(provisionContext);

            var webPartModel = provisionContext.WebPartDefinition;

            var listItemModelHost = provisionContext.ListItemModelHost;
            var typedDefinition   = webPartModel.WithAssertAndCast <XsltListViewWebPartDefinition>("model", value => value.RequireNotNull());

            var webPartStoreKey = provisionContext.WebPartStoreKey;
            var context         = provisionContext.ListItemModelHost.HostWeb.Context;

            var bindContext = LookupBindContext(listItemModelHost, typedDefinition);

            if (provisionContext.WebPartStoreKey.HasValue &&
                provisionContext.WebPartStoreKey.Value != default(Guid))
            {
                var targetWeb = listItemModelHost.HostWeb;

                if (typedDefinition.WebId.HasGuidValue() || !string.IsNullOrEmpty(typedDefinition.WebUrl))
                {
                    var lookupFieldModelHandler = new LookupFieldModelHandler();

                    targetWeb = lookupFieldModelHandler.GetTargetWeb(
                        this.CurrentClientContext.Site,
                        typedDefinition.WebUrl,
                        typedDefinition.WebId,
                        provisionContext.ListItemModelHost);
                }

                var list       = LookupList(targetWeb, typedDefinition.ListUrl, typedDefinition.ListTitle, typedDefinition.ListId);
                var hiddenView = list.Views.GetById(provisionContext.WebPartStoreKey.Value);

                context.Load(hiddenView, s => s.HtmlSchemaXml);

                context.Load(hiddenView);
                context.ExecuteQueryWithTrace();

                // always replace HtmlSchemaXml witjh the real view
                // some properties aren't coming with CSOM

                if (bindContext.OriginalView != null)
                {
                    var updatedSchemaXml  = XDocument.Parse(hiddenView.HtmlSchemaXml);
                    var originalSchemaXml = XDocument.Parse(bindContext.OriginalView.HtmlSchemaXml);

                    updatedSchemaXml.Root.ReplaceWith(originalSchemaXml.Root);

#if !NET35
                    hiddenView.ListViewXml = updatedSchemaXml.Root.GetInnerXmlAsString();
#endif
                }

                if (!string.IsNullOrEmpty(typedDefinition.Toolbar))
                {
                    // work with the update schema XML
                    var htmlSchemaXml = XDocument.Parse(hiddenView.HtmlSchemaXml);

                    if (bindContext.OriginalView != null)
                    {
                        htmlSchemaXml = XDocument.Parse(bindContext.OriginalView.HtmlSchemaXml);
                    }

                    var useShowAlwaysValue =
                        (typedDefinition.Toolbar.ToUpper() == BuiltInToolbarType.Standard.ToUpper()) &&
                        typedDefinition.ToolbarShowAlways.HasValue &&
                        typedDefinition.ToolbarShowAlways.Value;

                    var toolbarNode = htmlSchemaXml.Root
                                      .Descendants("Toolbar")
                                      .FirstOrDefault();

                    if (toolbarNode == null)
                    {
                        toolbarNode = new XElement("Toolbar");
                        htmlSchemaXml.Root.Add(toolbarNode);
                    }

                    toolbarNode.SetAttributeValue("Type", typedDefinition.Toolbar);

                    if (useShowAlwaysValue)
                    {
                        toolbarNode.SetAttributeValue("ShowAlways", "TRUE");
                    }
                    else
                    {
                        XAttribute attr = toolbarNode.Attribute("ShowAlways");
                        if (attr != null && string.IsNullOrEmpty(attr.Value))
                        {
                            attr.Remove();
                        }
                    }

#if !NET35
                    hiddenView.ListViewXml = htmlSchemaXml.Root.GetInnerXmlAsString();
#endif
                }

                hiddenView.Update();
                context.ExecuteQueryWithTrace();
            }
        }
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            // base validation
            base.DeployModel(modelHost, model);


            // web specific validation
            var host       = modelHost.WithAssertAndCast <WebpartPageModelHost>("modelHost", value => value.RequireNotNull());
            var definition = model.WithAssertAndCast <ListViewWebPartDefinition>("model", value => value.RequireNotNull());

            WebPartExtensions.WithExistingWebPart(host.HostFile, definition, (spWebPartManager, spObject) =>
            {
                var web         = spWebPartManager.Web;
                var typedObject = spObject as ListViewWebPart;

                var assert = ServiceFactory.AssertService
                             .NewAssert(definition, typedObject)
                             .ShouldNotBeNull(typedObject);

                var typedDefinition = definition;
                var targetWeb       = web;

                // web url
                if (!string.IsNullOrEmpty(typedDefinition.WebUrl))
                {
                    var lookupFieldModelHandler = new LookupFieldModelHandler();
                    targetWeb = lookupFieldModelHandler.GetTargetWeb(web.Site,
                                                                     definition.WebUrl, definition.WebId);

                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.WebUrl);

                        var isValid = d.WebId == targetWeb.ID;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.WebUrl, "WebUrl is NULL. Skipping.");
                }

                if (typedDefinition.WebId.HasGuidValue())
                {
                    var lookupFieldModelHandler = new LookupFieldModelHandler();
                    targetWeb = lookupFieldModelHandler.GetTargetWeb(web.Site,
                                                                     definition.WebUrl, definition.WebId);

                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.WebId);

                        var isValid = d.WebId == targetWeb.ID;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.WebId, "WebId is NULL. Skipping.");
                }


                var targetList = web.Lists[typedObject.ListId];

                var hasList = !string.IsNullOrEmpty(definition.ListTitle) ||
                              !string.IsNullOrEmpty(definition.ListUrl) ||
                              definition.ListId.HasValue;
                var hasView = !string.IsNullOrEmpty(definition.ViewName) ||
                              definition.ViewId.HasValue;;

                // list
                if (!string.IsNullOrEmpty(definition.ListTitle))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ListTitle);
                        var dstProp = d.GetExpressionValue(o => o.ListId);

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = targetList.ID == (Guid)dstProp.Value
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ListTitle, "ListTitle is null or empty. Skipping.");
                }

                if (!string.IsNullOrEmpty(definition.ListUrl))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ListUrl);
                        var dstProp = d.GetExpressionValue(o => o.ListId);

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = targetList.ID == (Guid)dstProp.Value
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ListUrl, "ListUrl is null or empty. Skipping.");
                }

                if (definition.ListId.HasValue && definition.ListId != default(Guid))
                {
                    assert.ShouldBeEqual(m => m.ListId, o => o.ListId);
                }
                else
                {
                    assert.SkipProperty(m => m.ListId, "ListId is null or empty. Skipping.");
                }

                // view
                if (definition.ViewId.HasValue)
                {
                    // web part gonna have hidden view
                    // so validation is a bit tricky, done by other properties

                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcView = targetList.Views[s.ViewId.Value];
                        var dstView = targetList.Views[new Guid(typedObject.ViewGuid)];

                        var srcProp = s.GetExpressionValue(m => m.ViewId);
                        var dstProp = d.GetExpressionValue(o => o.ViewGuid);

                        var isValid = srcView.ViewFields.Count == dstView.ViewFields.Count &&
                                      srcView.Query == dstView.Query;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ViewId, "ViewId is null or empty. Skipping.");
                }

                if (!string.IsNullOrEmpty(definition.ViewName))
                {
                    // web part gonna have hidden view
                    // so validation is a bit tricky, done by other properties

                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcView = targetList.Views[s.ViewName];
                        var dstView = targetList.Views[new Guid(typedObject.ViewGuid)];

                        var srcProp = s.GetExpressionValue(m => m.ViewName);
                        var dstProp = d.GetExpressionValue(o => o.ViewGuid);

                        var isValid = srcView.ViewFields.Count == dstView.ViewFields.Count &&
                                      srcView.Query == dstView.Query;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ViewName, "ViewName is null or empty. Skipping.");
                }

                //  title link
                if (string.IsNullOrEmpty(definition.TitleUrl))
                {
                    // list?
                    if (hasView)
                    {
                        assert.ShouldBeEqual((p, s, d) =>
                        {
                            var srcProp = s.GetExpressionValue(m => m.TitleUrl);
                            var srcView = string.IsNullOrEmpty(s.ViewName) ?
                                          targetList.Views[s.ViewId.Value] :
                                          targetList.Views[s.ViewName];

                            return(new PropertyValidationResult
                            {
                                Tag = p.Tag,
                                Src = srcProp,
                                Dst = null,
                                IsValid = srcView.ServerRelativeUrl.StartsWith(typedObject.TitleUrl)
                            });
                        });
                    }
                    else if (hasList)
                    {
                        assert.ShouldBeEqual((p, s, d) =>
                        {
                            var srcProp = s.GetExpressionValue(m => m.TitleUrl);

                            return(new PropertyValidationResult
                            {
                                Tag = p.Tag,
                                Src = srcProp,
                                Dst = null,
                                IsValid = targetList.DefaultViewUrl.StartsWith(typedObject.TitleUrl)
                            });
                        });
                    }
                }
                else
                {
                    assert.ShouldBeEqual(m => m.TitleUrl, o => o.TitleUrl);
                }


                // skip it, it will be part of the .Toolbar validation
                assert.SkipProperty(m => m.ToolbarShowAlways, "");

                if (!string.IsNullOrEmpty(definition.Toolbar))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var list = XsltListViewWebPartModelHandler.GetTargetList(targetWeb,
                                                                                 typedDefinition.ListTitle,
                                                                                 typedDefinition.ListUrl,
                                                                                 typedDefinition.ListId);

                        var targetView    = list.Views[Guid.Parse((spObject as ListViewWebPart).ViewGuid)];
                        var htmlSchemaXml = XDocument.Parse(targetView.HtmlSchemaXml);

                        var useShowAlwaysValue =
                            (typedDefinition.Toolbar.ToUpper() == BuiltInToolbarType.Standard.ToUpper()) &&
                            typedDefinition.ToolbarShowAlways.HasValue &&
                            typedDefinition.ToolbarShowAlways.Value;

                        var toolbarNode = htmlSchemaXml.Root
                                          .Descendants("Toolbar")
                                          .FirstOrDefault();

                        // NONE? the node might not be there
                        if ((typedDefinition.Toolbar.ToUpper() == BuiltInToolbarType.None.ToUpper()) &&
                            (toolbarNode == null))
                        {
                            var srcProp = s.GetExpressionValue(m => m.Toolbar);

                            return(new PropertyValidationResult
                            {
                                Tag = p.Tag,
                                Src = srcProp,
                                Dst = null,
                                IsValid = true
                            });
                        }
                        else
                        {
                            var toolBarValue = toolbarNode.GetAttributeValue("Type");

                            var srcProp = s.GetExpressionValue(m => m.Toolbar);
                            var isValid = toolBarValue.ToUpper() == definition.Toolbar.ToUpper();

                            if (useShowAlwaysValue)
                            {
                                var showAlwaysValue = toolbarNode.GetAttributeValue("ShowAlways");
                                isValid             = isValid && (showAlwaysValue.ToUpper() == "TRUE");
                            }

                            return(new PropertyValidationResult
                            {
                                Tag = p.Tag,
                                Src = srcProp,
                                Dst = null,
                                IsValid = isValid
                            });
                        }
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.Toolbar);
                }
            });
        }
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            var definition = model.WithAssertAndCast <FieldDefinition>("model", value => value.RequireNotNull());
            var spObject   = GetField(modelHost, definition);

            HostList = ExtractListFromHost(modelHost);
            HostSite = ExtractSiteFromHost(modelHost);

            var assert = ServiceFactory.AssertService.NewAssert(model, definition, spObject);

            ValidateField(assert, spObject, definition);

            var typedField      = spObject.Context.CastTo <FieldLookup>(spObject);
            var typedDefinition = model.WithAssertAndCast <LookupFieldDefinition>("model", value => value.RequireNotNull());

            var typedFieldAssert = ServiceFactory.AssertService.NewAssert(model, typedDefinition, typedField);

            typedFieldAssert.ShouldBeEqual(m => m.AllowMultipleValues, o => o.AllowMultipleValues);

            if (typedDefinition.LookupWebId.HasValue)
            {
                typedFieldAssert.ShouldBeEqual(m => m.LookupWebId, o => o.LookupWebId);
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupWebId, "LookupWebId is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupWebUrl))
            {
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupWebUrl, "LookupWebUrl is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.RelationshipDeleteBehavior))
            {
                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.RelationshipDeleteBehavior);
                    var isValid = s.RelationshipDeleteBehavior == d.RelationshipDeleteBehavior.ToString();

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.RelationshipDeleteBehavior, "RelationshipDeleteBehavior is NULL. Skipping.");
            }

            // web url
            if (!string.IsNullOrEmpty(typedDefinition.LookupWebUrl))
            {
                var lookupFieldModelHandler = new LookupFieldModelHandler();
                var targetWeb = lookupFieldModelHandler.GetTargetWeb(HostSite, typedDefinition);

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupWebUrl);

                    var isValid = d.LookupWebId == targetWeb.Id;

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupWebUrl, "LookupWebUrl is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupListTitle))
            {
                var site    = HostSite;
                var context = site.Context;

                var lookupFieldModelHandler = new LookupFieldModelHandler();
                var web = lookupFieldModelHandler.GetTargetWeb(site, typedDefinition);


                context.Load(web);
                context.ExecuteQueryWithTrace();

                var list = web.Lists.GetByTitle(typedDefinition.LookupListTitle);

                context.Load(list);
                context.ExecuteQueryWithTrace();

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupListTitle);

                    var isValid = list.Id == new Guid(typedField.LookupList);

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupListTitle, "LookupListTitle is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupListUrl))
            {
                var site    = HostSite;
                var context = site.Context;


                var lookupFieldModelHandler = new LookupFieldModelHandler();
                var web = lookupFieldModelHandler.GetTargetWeb(site, typedDefinition);


                context.Load(web);
                context.ExecuteQueryWithTrace();

                var list = web.QueryAndGetListByUrl(UrlUtility.CombineUrl(web.ServerRelativeUrl, typedDefinition.LookupListUrl));

                context.Load(list);
                context.ExecuteQueryWithTrace();

                typedFieldAssert.ShouldBeEqual((p, s, d) =>
                {
                    var srcProp = s.GetExpressionValue(m => m.LookupListUrl);

                    var isValid = list.Id == new Guid(typedField.LookupList);

                    return(new PropertyValidationResult
                    {
                        Tag = p.Tag,
                        Src = srcProp,
                        Dst = null,
                        IsValid = isValid
                    });
                });
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupListUrl, "LookupListUrl is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupList))
            {
                if (typedDefinition.LookupList.ToUpper() == "USERINFO")
                {
                    typedFieldAssert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.LookupList);

                        var site    = HostSite;
                        var context = site.Context;

                        var userInfoList = site.RootWeb.SiteUserInfoList;
                        context.Load(userInfoList);
                        context.ExecuteQueryWithTrace();

                        var isValid = userInfoList.Id == new Guid(typedField.LookupList);

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    typedFieldAssert.ShouldBeEqual(m => m.LookupList, o => o.LookupList);
                }
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupList, "LookupList is NULL. Skipping.");
            }

            if (!string.IsNullOrEmpty(typedDefinition.LookupField))
            {
                typedFieldAssert.ShouldBeEqual(m => m.LookupField, o => o.LookupField);
            }
            else
            {
                typedFieldAssert.SkipProperty(m => m.LookupField, "LookupField is NULL. Skipping.");
            }
        }
Пример #11
0
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            // base validation
            base.DeployModel(modelHost, model);

            // content editor specific validation

            var host            = modelHost.WithAssertAndCast <WebpartPageModelHost>("modelHost", value => value.RequireNotNull());
            var typedDefinition = model.WithAssertAndCast <ContentByQueryWebPartDefinition>("model", value => value.RequireNotNull());

            CurrentHost = host;

            //var item = host.PageListItem;

            WebPartExtensions.WithExistingWebPart(host.HostFile, typedDefinition, (spWebPartManager, spObject) =>
            {
                var typedWebPart = spObject as ContentByQueryWebPart;

                var assert = ServiceFactory.AssertService
                             .NewAssert(typedDefinition, typedWebPart)
                             .ShouldNotBeNull(typedWebPart);

                if (!string.IsNullOrEmpty(typedDefinition.ContentTypeBeginsWithId))
                {
                    assert.ShouldBeEqual(m => m.ContentTypeBeginsWithId, o => o.ContentTypeBeginsWithId);
                }
                else
                {
                    assert.SkipProperty(m => m.ContentTypeBeginsWithId, "ContentTypeBeginsWithId is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.DataMappings))
                {
                    assert.ShouldBeEqual(m => m.DataMappings, o => o.DataMappings);
                }
                else
                {
                    assert.SkipProperty(m => m.DataMappings, "DataMappings is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.DataMappingViewFields))
                {
                    assert.ShouldBeEqual(m => m.DataMappingViewFields, o => o.DataMappingViewFields);
                }
                else
                {
                    assert.SkipProperty(m => m.DataMappingViewFields, "DataMappingViewFields is null or empty, skipping.");
                }

                // filter display value 1-2-3
                if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue1))
                {
                    assert.ShouldBeEqual(m => m.FilterDisplayValue1, o => o.FilterDisplayValue1);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterDisplayValue1, "FilterDisplayValue1 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue2))
                {
                    assert.ShouldBeEqual(m => m.FilterDisplayValue2, o => o.FilterDisplayValue2);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterDisplayValue2, "FilterDisplayValue2 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterDisplayValue3))
                {
                    assert.ShouldBeEqual(m => m.FilterDisplayValue3, o => o.FilterDisplayValue3);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterDisplayValue3, "FilterDisplayValue3 is null or empty, skipping.");
                }

                // operators 1-2-3
                if (!string.IsNullOrEmpty(typedDefinition.FilterOperator1))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterOperator1);
                        var isValid = false;

                        isValid = s.FilterOperator1.ToLower() == d.FilterOperator1.ToString().ToLower();

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterOperator1, "FilterOperator1 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterOperator2))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterOperator2);
                        var isValid = false;

                        isValid = s.FilterOperator2.ToLower() == d.FilterOperator2.ToString().ToLower();

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterOperator2, "FilterOperator2 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterOperator3))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.FilterOperator3);
                        var isValid = false;

                        isValid = s.FilterOperator3.ToLower() == d.FilterOperator3.ToString().ToLower();

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.FilterOperator3, "FilterOperator3 is null or empty, skipping.");
                }

                // type 1-2-3
                if (!string.IsNullOrEmpty(typedDefinition.FilterType1))
                {
                    assert.ShouldBeEqual(m => m.FilterType1, o => o.FilterType1);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterType1, "FilterType1 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterType2))
                {
                    assert.ShouldBeEqual(m => m.FilterType2, o => o.FilterType2);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterType2, "FilterType2 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterType3))
                {
                    assert.ShouldBeEqual(m => m.FilterType3, o => o.FilterType3);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterType3, "FilterType3 is null or empty, skipping.");
                }

                // filter values 1-2-3
                if (!string.IsNullOrEmpty(typedDefinition.FilterValue1))
                {
                    assert.ShouldBeEqual(m => m.FilterValue1, o => o.FilterValue1);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterValue1, "FilterValue1 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterValue2))
                {
                    assert.ShouldBeEqual(m => m.FilterValue2, o => o.FilterValue2);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterValue2, "FilterValue2 is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.FilterValue3))
                {
                    assert.ShouldBeEqual(m => m.FilterValue3, o => o.FilterValue3);
                }
                else
                {
                    assert.SkipProperty(m => m.FilterValue3, "FilterValue3 is null or empty, skipping.");
                }

                // sorting

                if (!string.IsNullOrEmpty(typedDefinition.SortBy))
                {
                    assert.ShouldBeEqual(m => m.SortBy, o => o.SortBy);
                }
                else
                {
                    assert.SkipProperty(m => m.SortBy, "SortBy is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.SortByFieldType))
                {
                    assert.ShouldBeEqual(m => m.SortByFieldType, o => o.SortByFieldType);
                }
                else
                {
                    assert.SkipProperty(m => m.SortByFieldType, "SortByFieldType is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.SortByDirection))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.SortByDirection);
                        var isValid = false;

                        isValid = s.SortByDirection.ToLower() == d.SortByDirection.ToString().ToLower();

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.SortByDirection, "SortByDirection is null or empty, skipping.");
                }

                // xslt
                if (!string.IsNullOrEmpty(typedDefinition.GroupStyle))
                {
                    assert.ShouldBeEqual(m => m.GroupStyle, o => o.GroupStyle);
                }
                else
                {
                    assert.SkipProperty(m => m.GroupStyle, "GroupStyle is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.ItemStyle))
                {
                    assert.ShouldBeEqual(m => m.ItemStyle, o => o.ItemStyle);
                }
                else
                {
                    assert.SkipProperty(m => m.ItemStyle, "ItemStyle is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.ItemXslLink))
                {
                    // TODO
                }
                else
                {
                    assert.SkipProperty(m => m.ItemXslLink, "ItemXslLink is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.MainXslLink))
                {
                    // TODO
                }
                else
                {
                    assert.SkipProperty(m => m.MainXslLink, "MainXslLink is null or empty, skipping.");
                }


                // list name/url/id
                if (!string.IsNullOrEmpty(typedDefinition.ListName))
                {
                    // TODO
                }
                else
                {
                    assert.SkipProperty(m => m.ListName, "ListName is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.ListUrl))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ListUrl);
                        var isValid = false;

                        // resolve web / url by list URL
                        // check ListId

                        var webLookup = new LookupFieldModelHandler();

                        using (var targetWeb = webLookup.GetTargetWeb(CurrentHost.HostFile.Web.Site,
                                                                      typedDefinition.WebUrl,
                                                                      typedDefinition.WebId))
                        {
                            var listUrl = SPUrlUtility.CombineUrl(targetWeb.ServerRelativeUrl, typedDefinition.ListUrl);
                            var list    = targetWeb.GetList(listUrl);

                            isValid = typedWebPart.ListGuid == list.ID.ToString("D");
                        }

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ListUrl, "ListUrl is null or empty, skipping.");
                }

                if (typedDefinition.ListGuid.HasValue)
                {
                    // TODO
                }
                else
                {
                    assert.SkipProperty(m => m.ListGuid, "ListGuid is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.WebUrl))
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.WebUrl);
                        var isValid = false;

                        isValid = s.WebUrl == d.WebUrl;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.WebUrl, "WebUrl is null or empty, skipping.");
                }

                if (typedDefinition.WebId.HasValue)
                {
                    // TODO
                }
                else
                {
                    assert.SkipProperty(m => m.WebId, "WebId is null or empty, skipping.");
                }

                // misc

                if (typedDefinition.ItemLimit.HasValue)
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ItemLimit);
                        var isValid = false;

                        isValid = s.ItemLimit == d.ItemLimit;

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ItemLimit, "ItemLimit is null or empty, skipping.");
                }

                if (typedDefinition.PlayMediaInBrowser.HasValue)
                {
                    assert.ShouldBeEqual(m => m.PlayMediaInBrowser, o => o.PlayMediaInBrowser);
                }
                else
                {
                    assert.SkipProperty(m => m.PlayMediaInBrowser, "PlayMediaInBrowser is null or empty, skipping.");
                }

                if (typedDefinition.ShowUntargetedItems.HasValue)
                {
                    assert.ShouldBeEqual(m => m.ShowUntargetedItems, o => o.ShowUntargetedItems);
                }
                else
                {
                    assert.SkipProperty(m => m.ShowUntargetedItems, "ShowUntargetedItems is null or empty, skipping.");
                }

                if (typedDefinition.UseCopyUtil.HasValue)
                {
                    assert.ShouldBeEqual(m => m.UseCopyUtil, o => o.UseCopyUtil);
                }
                else
                {
                    assert.SkipProperty(m => m.UseCopyUtil, "UseCopyUtil is null or empty, skipping.");
                }

                if (typedDefinition.ServerTemplate.HasValue)
                {
                    assert.ShouldBeEqual((p, s, d) =>
                    {
                        var srcProp = s.GetExpressionValue(m => m.ServerTemplate);
                        var isValid = false;

                        isValid = s.ServerTemplate == ConvertUtils.ToInt(d.ServerTemplate);

                        return(new PropertyValidationResult
                        {
                            Tag = p.Tag,
                            Src = srcProp,
                            Dst = null,
                            IsValid = isValid
                        });
                    });
                }
                else
                {
                    assert.SkipProperty(m => m.ServerTemplate, "ServerTemplate is null or empty, skipping.");
                }

                if (!string.IsNullOrEmpty(typedDefinition.GroupBy))
                {
                    assert.ShouldBeEqual(m => m.GroupBy, o => o.GroupBy);
                }
                else
                {
                    assert.SkipProperty(m => m.GroupBy, "GroupBy is null or empty, skipping.");
                }

                if (typedDefinition.DisplayColumns.HasValue)
                {
                    assert.ShouldBeEqual(m => m.DisplayColumns, o => o.DisplayColumns);
                }
                else
                {
                    assert.SkipProperty(m => m.DisplayColumns, "DisplayColumns is null or empty, skipping.");
                }
            });
        }