protected override void DeployModelInternal(object modelHost, DefinitionBase model)
        {
            var   webModel  = model.WithAssertAndCast <WebDefinition>("model", value => value.RequireNotNull());
            SPWeb parentWeb = null;

            if (modelHost is SiteModelHost)
            {
                parentWeb = (modelHost as SiteModelHost).HostSite.RootWeb;
            }

            if (modelHost is WebModelHost)
            {
                parentWeb = (modelHost as WebModelHost).HostWeb;
            }

            TraceUtils.WithScope(traceScope =>
            {
                var web  = GetWeb(parentWeb, webModel);
                var pair = new ComparePair <WebDefinition, SPWeb>(webModel, web);

                traceScope.WriteLine(string.Format("Validating model:[{0}] web:[{1}]", webModel, web));

                traceScope.WithTraceIndent(trace => pair
                                           .ShouldBeEqual(trace, m => m.Title, w => w.Title)
                                           .ShouldBeEqual(trace, m => m.Description, w => w.Description)
                                           .ShouldBeEqual(trace, m => m.WebTemplate, w => string.Format("{0}#{1}", w.WebTemplate, w.Configuration)));
            });
        }
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            var siteModelHost = modelHost.WithAssertAndCast<SiteModelHost>("modelHost", value => value.RequireNotNull());
            var contentTypeModel = model.WithAssertAndCast<ContentTypeDefinition>("model", value => value.RequireNotNull());

            var site = siteModelHost.HostSite;

            var context = site.Context;
            var rootWeb = site.RootWeb;

            var contentTypes = rootWeb.ContentTypes;

            context.Load(rootWeb);
            context.Load(contentTypes);

            context.ExecuteQuery();

            var contentTypeId = contentTypeModel.GetContentTypeId();
            var spObject = contentTypes.FirstOrDefault(c => c.StringId.ToLower() == contentTypeId.ToLower());

            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair<ContentTypeDefinition, ContentType>(contentTypeModel, spObject);

                traceScope.WriteLine(string.Format("Validating model:[{0}] field:[{1}]", model, spObject));

                traceScope.WithTraceIndent(trace => pair
                    .ShouldBeEqual(trace, m => m.Name, o => o.Name)
                    .ShouldBeEqual(trace, m => m.Description, o => o.Description)
                    .ShouldBeEqual(trace, m => m.Group, o => o.Group)
                    .ShouldBeEqual(trace, m => m.GetContentTypeId().ToLowerInvariant(), o => o.Id.ToString().ToLowerInvariant())
                    .ShouldBeEqual(trace, m => m.Group, o => o.Group));
            });
        }
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            var siteModelHost    = modelHost.WithAssertAndCast <SiteModelHost>("modelHost", value => value.RequireNotNull());
            var contentTypeModel = model.WithAssertAndCast <ContentTypeDefinition>("model", value => value.RequireNotNull());

            var site = siteModelHost.HostSite;

            var context = site.Context;
            var rootWeb = site.RootWeb;

            var contentTypes = rootWeb.ContentTypes;

            context.Load(rootWeb);
            context.Load(contentTypes);

            context.ExecuteQuery();

            var contentTypeId = contentTypeModel.GetContentTypeId();
            var spObject      = contentTypes.FirstOrDefault(c => c.StringId.ToLower() == contentTypeId.ToLower());

            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair <ContentTypeDefinition, ContentType>(contentTypeModel, spObject);

                traceScope.WriteLine(string.Format("Validating model:[{0}] field:[{1}]", model, spObject));

                traceScope.WithTraceIndent(trace => pair
                                           .ShouldBeEqual(trace, m => m.Name, o => o.Name)
                                           .ShouldBeEqual(trace, m => m.Description, o => o.Description)
                                           .ShouldBeEqual(trace, m => m.Group, o => o.Group)
                                           .ShouldBeEqual(trace, m => m.GetContentTypeId().ToLowerInvariant(), o => o.Id.ToString().ToLowerInvariant())
                                           .ShouldBeEqual(trace, m => m.Group, o => o.Group));
            });
        }
        private void ValidateFolderProps(Folder folder, FolderDefinition folderModel)
        {
            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair <FolderDefinition, Folder>(folderModel, folder);

                traceScope.WriteLine(string.Format("Validating model:[{0}] folder:[{1}]", folderModel, folder));

                traceScope.WithTraceIndent(trace => pair
                                           .ShouldBeEqual(trace, m => m.Name, o => o.Name));
            });
        }
        private void ValidateFolderProps(Folder folder, FolderDefinition folderModel)
        {
            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair<FolderDefinition, Folder>(folderModel, folder);

                traceScope.WriteLine(string.Format("Validating model:[{0}] folder:[{1}]", folderModel, folder));

                traceScope.WithTraceIndent(trace => pair
                    .ShouldBeEqual(trace, m => m.Name, o => o.Name));
            });
        }
Example #6
0
        private void listView1_SelectedIndexChanged(Object sender, EventArgs e)
        {
            if (listView1.FocusedItem != null)
            {
                ListViewItem item = listView1.FocusedItem;

                ComparePair pair = (ComparePair)item.Tag;

                String script1 = pair.DestinationObject?.CreateScript();
                String script2 = pair.SourceObject?.CreateScript();

                diffControl.SetText(script1, script2);
            }
        }
        private void ValidateNode(NavigationNode qlNode, QuickLaunchNavigationNodeDefinition quickLaunchModel)
        {
            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair <QuickLaunchNavigationNodeDefinition, NavigationNode>(quickLaunchModel, qlNode);

                traceScope.WriteLine(string.Format("Validating model:[{0}] node:[{1}]", quickLaunchModel, qlNode));

                traceScope.WithTraceIndent(trace => pair
                                           .ShouldBeEqual(trace, m => m.Title, o => o.Title)
                                           .ShouldBeEqual(trace, m => m.Url, o => o.Url)
                                           .ShouldBeEqual(trace, m => m.IsVisible, o => o.IsVisible)
                                           .ShouldBeEqual(trace, m => m.IsExternal, o => o.IsExternal));
            });
        }
        private void ValidateNode(NavigationNode qlNode, QuickLaunchNavigationNodeDefinition quickLaunchModel)
        {
            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair<QuickLaunchNavigationNodeDefinition, NavigationNode>(quickLaunchModel, qlNode);

                traceScope.WriteLine(string.Format("Validating model:[{0}] node:[{1}]", quickLaunchModel, qlNode));

                traceScope.WithTraceIndent(trace => pair
                    .ShouldBeEqual(trace, m => m.Title, o => o.Title)
                    .ShouldBeEqual(trace, m => m.Url, o => o.Url)
                    .ShouldBeEqual(trace, m => m.IsVisible, o => o.IsVisible)
                    .ShouldBeEqual(trace, m => m.IsExternal, o => o.IsExternal));
            });
        }
        private void ValidateSiteField(SiteModelHost siteModelHost, FieldDefinition model)
        {
            var spObject = FindSiteField(siteModelHost, model);

            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair<FieldDefinition, Field>(model, spObject);

                traceScope.WriteLine(string.Format("Validating model:[{0}] field:[{1}]", model, spObject));

                traceScope.WithTraceIndent(trace => pair
                    .ShouldBeEqual(trace, m => m.Title, o => o.Title)
                    .ShouldBeEqual(trace, m => m.InternalName, o => o.InternalName)
                    .ShouldBeEqual(trace, m => m.Id, o => o.Id)
                    .ShouldBeEqual(trace, m => m.Description, o => o.Description)
                    .ShouldBeEqual(trace, m => m.Group, o => o.Group));
            });
        }
        private void ValidateSiteField(SiteModelHost siteModelHost, FieldDefinition model)
        {
            var spObject = FindSiteField(siteModelHost, model);

            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair <FieldDefinition, Field>(model, spObject);

                traceScope.WriteLine(string.Format("Validating model:[{0}] field:[{1}]", model, spObject));

                traceScope.WithTraceIndent(trace => pair
                                           .ShouldBeEqual(trace, m => m.Title, o => o.Title)
                                           .ShouldBeEqual(trace, m => m.InternalName, o => o.InternalName)
                                           .ShouldBeEqual(trace, m => m.Id, o => o.Id)
                                           .ShouldBeEqual(trace, m => m.Description, o => o.Description)
                                           .ShouldBeEqual(trace, m => m.Group, o => o.Group));
            });
        }
Example #11
0
        public static ComparePair <TModel, TObj> ShouldBeEqual <TModel, TObj>(
            this ComparePair <TModel, TObj> pair,
            TraceUtils trace,
            Expression <Func <TModel, int> > modelPropExp,
            Expression <Func <TObj, int> > objPropLExp)
        {
            var modelProp = pair.Model.GetExpressionValue <TModel, int>(modelPropExp);
            var objProp   = pair.Object.GetExpressionValue <TObj, int>(objPropLExp);

            trace.WriteLine(string.Format("Model prop [{0}] on obj prop [{1}]: model:[{2}] obj:[{3}]",
                                          modelProp.Name,
                                          objProp.Name,
                                          modelProp.Value,
                                          objProp.Value));

            Assert.AreEqual(modelProp.Value, objProp.Value);

            return(pair);
        }
        private void ValidateModel(SiteModelHost siteModelHost, UserCustomActionDefinition customActionModel)
        {
            var customAction = GetCustomAction(siteModelHost, customActionModel);

            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair <UserCustomActionDefinition, UserCustomAction>(customActionModel, customAction);

                traceScope.WriteLine(string.Format("Validating model:[{0}] custom action:[{1}]", customActionModel, customAction));

                traceScope.WithTraceIndent(trace => pair
                                           .ShouldBeEqual(trace, m => m.Title, o => o.Title)
                                           .ShouldBeEqual(trace, m => m.Description, o => o.Description)
                                           .ShouldBeEqual(trace, m => m.Group, o => o.Group)
                                           .ShouldBeEqual(trace, m => m.Name, o => o.Name)
                                           .ShouldBeEqual(trace, m => m.Sequence, o => o.Sequence)
                                           .ShouldBeEqual(trace, m => m.Location, o => o.Location));
            });
        }
        private void ValidateModel(SiteModelHost siteModelHost, UserCustomActionDefinition customActionModel)
        {
            var customAction = GetCustomAction(siteModelHost, customActionModel);

            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair<UserCustomActionDefinition, UserCustomAction>(customActionModel, customAction);

                traceScope.WriteLine(string.Format("Validating model:[{0}] custom action:[{1}]", customActionModel, customAction));

                traceScope.WithTraceIndent(trace => pair
                    .ShouldBeEqual(trace, m => m.Title, o => o.Title)
                    .ShouldBeEqual(trace, m => m.Description, o => o.Description)
                    .ShouldBeEqual(trace, m => m.Group, o => o.Group)
                    .ShouldBeEqual(trace, m => m.Name, o => o.Name)
                    .ShouldBeEqual(trace, m => m.Sequence, o => o.Sequence)
                    .ShouldBeEqual(trace, m => m.Location, o => o.Location));
            });
        }
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            var webModelHost = modelHost.WithAssertAndCast<WebModelHost>("modelHost", value => value.RequireNotNull());
            var listModel = model.WithAssertAndCast<ListDefinition>("model", value => value.RequireNotNull());

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

            context.Load(web, w => w.ServerRelativeUrl);
            context.Load(web, w => w.Lists);
            context.ExecuteQuery();

            var spObject = FindListByTitle(web.Lists, listModel.Title);

            context.Load(spObject, list => list.RootFolder.ServerRelativeUrl);
            context.ExecuteQuery();

            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair<ListDefinition, List>(listModel, spObject);

                traceScope.WriteLine(string.Format("Validating model:[{0}] field:[{1}]", model, spObject));

                traceScope.WithTraceIndent(trace => pair
                    .ShouldBeEqual(trace, m => m.Title, o => o.Title)
                    .ShouldBeEqual(trace, m => m.Description, o => o.Description)
                    .ShouldBeEqual(trace, m => m.GetServerRelativeUrl(web), o => o.GetServerRelativeUrl())
                    .ShouldBeEqual(trace, m => m.ContentTypesEnabled, o => o.ContentTypesEnabled));

                if (listModel.TemplateType > 0)
                {
                    traceScope.WithTraceIndent(trace => pair
                        .ShouldBeEqual(trace, m => m.TemplateType, o => (int)o.BaseTemplate));
                }
                else
                {

                }
            });
        }
Example #15
0
        protected override void DeployModelInternal(object modelHost, DefinitionBase model)
        {
            var siteModelHost = modelHost.WithAssertAndCast <SiteModelHost>("modelHost", value => value.RequireNotNull());
            var fieldModel    = model.WithAssertAndCast <FieldDefinition>("model", value => value.RequireNotNull());

            var site = siteModelHost.HostSite;

            TraceUtils.WithScope(traceScope =>
            {
                var spField = GetField(modelHost, fieldModel);
                var pair    = new ComparePair <FieldDefinition, SPField>(fieldModel, spField);

                traceScope.WriteLine(string.Format("Validating model:[{0}] field:[{1}]", fieldModel, spField));

                traceScope.WithTraceIndent(trace => pair
                                           .ShouldBeEqual(trace, m => m.Title, w => w.Title)
                                           .ShouldBeEqual(trace, m => m.Description, w => w.Description)
                                           .ShouldBeEqual(trace, m => m.Group, w => w.Group)
                                           .ShouldBeEqual(trace, m => m.InternalName, w => w.InternalName)
                                           .ShouldBeEqual(trace, m => m.Id, w => w.Id));
            });
        }
        protected override void DeployModelInternal(object modelHost, DefinitionBase model)
        {
            var siteModelHost = modelHost.WithAssertAndCast<SiteModelHost>("modelHost", value => value.RequireNotNull());
            var fieldModel = model.WithAssertAndCast<FieldDefinition>("model", value => value.RequireNotNull());

            var site = siteModelHost.HostSite;

            TraceUtils.WithScope(traceScope =>
            {
                var spField = GetField(modelHost, fieldModel);
                var pair = new ComparePair<FieldDefinition, SPField>(fieldModel, spField);

                traceScope.WriteLine(string.Format("Validating model:[{0}] field:[{1}]", fieldModel, spField));

                traceScope.WithTraceIndent(trace => pair
                    .ShouldBeEqual(trace, m => m.Title, w => w.Title)
                    .ShouldBeEqual(trace, m => m.Description, w => w.Description)
                    .ShouldBeEqual(trace, m => m.Group, w => w.Group)
                    .ShouldBeEqual(trace, m => m.InternalName, w => w.InternalName)
                    .ShouldBeEqual(trace, m => m.Id, w => w.Id));
            });
        }
        public override void DeployModel(object modelHost, DefinitionBase model)
        {
            var webModelHost = modelHost.WithAssertAndCast <WebModelHost>("modelHost", value => value.RequireNotNull());
            var listModel    = model.WithAssertAndCast <ListDefinition>("model", value => value.RequireNotNull());

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

            context.Load(web, w => w.ServerRelativeUrl);
            context.Load(web, w => w.Lists);
            context.ExecuteQuery();

            var spObject = FindListByTitle(web.Lists, listModel.Title);

            context.Load(spObject, list => list.RootFolder.ServerRelativeUrl);
            context.ExecuteQuery();

            TraceUtils.WithScope(traceScope =>
            {
                var pair = new ComparePair <ListDefinition, List>(listModel, spObject);

                traceScope.WriteLine(string.Format("Validating model:[{0}] field:[{1}]", model, spObject));

                traceScope.WithTraceIndent(trace => pair
                                           .ShouldBeEqual(trace, m => m.Title, o => o.Title)
                                           .ShouldBeEqual(trace, m => m.Description, o => o.Description)
                                           .ShouldBeEqual(trace, m => m.GetServerRelativeUrl(web), o => o.GetServerRelativeUrl())
                                           .ShouldBeEqual(trace, m => m.ContentTypesEnabled, o => o.ContentTypesEnabled));

                if (listModel.TemplateType > 0)
                {
                    traceScope.WithTraceIndent(trace => pair
                                               .ShouldBeEqual(trace, m => m.TemplateType, o => (int)o.BaseTemplate));
                }
                else
                {
                }
            });
        }
        protected override void DeployModelInternal(object modelHost, DefinitionBase model)
        {
            var webModel = model.WithAssertAndCast<WebDefinition>("model", value => value.RequireNotNull());
            SPWeb parentWeb = null;

            if (modelHost is SiteModelHost)
                parentWeb = (modelHost as SiteModelHost).HostSite.RootWeb;

            if (modelHost is WebModelHost)
                parentWeb = (modelHost as WebModelHost).HostWeb;

            TraceUtils.WithScope(traceScope =>
            {
                var web = GetWeb(parentWeb, webModel);
                var pair = new ComparePair<WebDefinition, SPWeb>(webModel, web);

                traceScope.WriteLine(string.Format("Validating model:[{0}] web:[{1}]", webModel, web));

                traceScope.WithTraceIndent(trace => pair
                    .ShouldBeEqual(trace, m => m.Title, w => w.Title)
                    .ShouldBeEqual(trace, m => m.Description, w => w.Description)
                    .ShouldBeEqual(trace, m => m.WebTemplate, w => string.Format("{0}#{1}", w.WebTemplate, w.Configuration)));
            });
        }