public void InjectModelsToDefinition(WebModelNode webDefinition)
 {
     webDefinition.AddFields(FieldDefnitions);
     webDefinition.AddContentType(ContentTypeDefinition, contentType =>
     {
         contentType
         .AddContentTypeFieldLinks(FieldDefnitions)
         .AddUniqueContentTypeFieldsOrder(new UniqueContentTypeFieldsOrderDefinition
         {
             Fields = FieldLinkValues()
         });
     });
     webDefinition.AddList(this.getListDefinition(), list =>
     {
         list
         .AddContentTypeLink(ContentTypeDefinition)
         .AddUniqueContentTypeOrder(new UniqueContentTypeOrderDefinition
         {
             ContentTypes = new List <ContentTypeLinkValue>
             {
                 new ContentTypeLinkValue {
                     ContentTypeName = ContentTypeDefinition.Name
                 },
             }
         })
         ;
     });
 }
        protected void AddListWorkflow(WebModelNode web)
        {
            var workflow           = ModelGeneratorService.GetRandomDefinition <SP2013WorkflowDefinition>();
            var workflowEnableList = ModelGeneratorService.GetRandomDefinition <ListDefinition>();

            var historyList = GetHistoryList();
            var taskList    = GetTaskList();

            web

            .AddList(historyList)
            .AddList(taskList)
            .AddList(workflowEnableList, list =>
            {
                list.AddSP2013WorkflowSubscription(new SP2013WorkflowSubscriptionDefinition
                {
                    Name = Rnd.String(),
                    WorkflowDisplayName = workflow.DisplayName,
#pragma warning disable 618
                    HistoryListUrl = historyList.GetListUrl(),
                    TaskListUrl    = taskList.GetListUrl()
#pragma warning restore 618
                });
            })
            .AddSP2013Workflow(workflow);
        }
Example #3
0
        public static WebModelNode AddWebFeature(this WebModelNode model, IEnumerable <FeatureDefinition> definitions)
        {
            foreach (var definition in definitions)
            {
                model.AddDefinitionNode(definition);
            }

            return(model);
        }
Example #4
0
 public static WebModelNode AddSampleCTCT(this WebModelNode node)
 {
     node
     .AddContentType(ContentType(), currentContentType =>
     {
         currentContentType
         fieldLinks
         ;
     });
     return(node);
 }
Example #5
0
        public static WebModelNode AddRandomDocumentLibrary(this WebModelNode model, Action <ListModelNode> action)
        {
            return(model.AddRandomTypedDefinition <ListDefinition, WebModelNode, ListModelNode>(node =>
            {
                var def = node.Value as ListDefinition;

                def.ContentTypesEnabled = true;
                def.TemplateType = BuiltInListTemplateTypeId.DocumentLibrary;

                action(node);
            }));
        }
Example #6
0
        private void AddAndCheckRandomAppWithVersion(WebModelNode web, Version version)
        {
            var def = new AppDefinition();

            def.ProductId = DefaultContainers.Apps.ProductId;
            def.Version   = version.ToString();

            def.Content = File.ReadAllBytes(string.Format(DefaultContainers.Apps.GenericVersionableAppFilePath, version));

            web.AddApp(def, app =>
            {
                app.OnProvisioned <object, AppDefinition>(context =>
                {
                    Trace.WriteLine(context.ObjectDefinition.ToString());
                    Trace.WriteLine(context.Object.ToString());

                    var expectedAppVersion = new Version(context.ObjectDefinition.Version);

                    var obj     = context.Object;
                    var objType = context.Object.GetType();

                    if (objType.ToString().Contains("Microsoft.SharePoint.Client.AppInstance"))
                    {
                        // with CSOM there is no API to know current app installed version
                        // checking if app is Installed after every single update
                        var appStatus = obj.GetPropertyValue("Status").ToString();

                        Assert.IsTrue(appStatus == "Installed",
                                      string.Format("App should be installed after every update"));
                    }
                    else if (objType.ToString().Contains("Microsoft.SharePoint.Administration.SPAppInstance"))
                    {
                        var appObjet = obj.GetPropertyValue("App");

                        var versionString = appObjet.GetPropertyValue("VersionString") as string;
                        var spAppVersion  = new Version(versionString);

                        // either equal (update) or SharePoint version greater than local (second update)
                        // the test is run several times, so only once we have =, and then we have <
                        Assert.IsTrue(expectedAppVersion <= spAppVersion,
                                      string.Format("Expecting app version:[{0}] SharePoint app version:[{1}]", expectedAppVersion, spAppVersion));
                    }
                    else
                    {
                        throw new SPMeta2NotImplementedException(string.Format("ID property extraction is not implemented for type: [{0}]", objType));
                    }
                });
            });
        }
Example #7
0
        protected void AddWebWorkflow(WebModelNode web)
        {
            var workflow = ModelGeneratorService.GetRandomDefinition <SP2013WorkflowDefinition>();

            var historyList = GetHistoryList();
            var taskList    = GetTaskList();

            web
            .AddList(historyList)
            .AddList(taskList)
            .AddSP2013Workflow(workflow)
            .AddSP2013WorkflowSubscription(new SP2013WorkflowSubscriptionDefinition
            {
                Name = Rnd.String(),
                WorkflowDisplayName = workflow.DisplayName,
                HistoryListUrl      = historyList.GetListUrl(),
                TaskListUrl         = taskList.GetListUrl()
            });
        }
Example #8
0
        private WebModelNode GetContainersModel(WebModelNode model)
        {
            WebModelNode containersModel = SPMeta2Model.NewWebModel();

            foreach (ModelNode modelNode in model.ChildModels)
            {
                if (modelNode.Value.GetType() == typeof(WebDefinition))
                {
                    containersModel.AddWeb((WebDefinition)modelNode.Value, currentWeb => {
                        GetWebContainersModel(currentWeb, modelNode.ChildModels);
                    });
                }

                if (modelNode.Value.GetType() == typeof(ListDefinition))
                {
                    containersModel.AddList((ListDefinition)modelNode.Value);
                }
            }

            return(containersModel);
        }
Example #9
0
 // Add new list method
 public static WebModelNode AddSampleList(this WebModelNode node)
 {
     node
     .AddList(List(), currentList =>
     {
         currentList
         .AddContentTypeLink(SampleCTCT.ContentType())
         .AddRemoveContentTypeLinks(new RemoveContentTypeLinksDefinition
         {
             ContentTypes = new List <ContentTypeLinkValue>
             {
                 new ContentTypeLinkValue {
                     ContentTypeId = BuiltInContentTypeId.Item
                 }
             }
         })
         .AddListView(AllItems())
         ;
     });
     return(node);
 }
Example #10
0
        protected void FillClientWebPartPages(WebModelNode web)
        {
            web.AddHostPagesList(list =>
            {
                list.AddRandomPublishingPage(page =>
                {
                    page.AddRandomWebpart();
                });
            });

            web.AddHostSitePagesList(list =>
            {
                list.AddRandomWikiPage(page =>
                {
                    page.AddRandomWebpart();
                });

                list.AddRandomWebPartPage(page =>
                {
                    page.AddRandomWebpart();
                });
            });
        }
Example #11
0
        public static void DeploySPMetaModel(this ClientContext Ctx, WebModelNode model, bool Incremental)
        {
            BeforeDeployModel(Incremental, x =>
            {
                PropertyBagValue incrementalProvisionModelIdProperty = model.PropertyBag.FirstOrDefault(currentPropertyValue =>
                                                                                                        currentPropertyValue.Name == "_sys.IncrementalProvision.PersistenceStorageModelId");
                if (Incremental && incrementalProvisionModelIdProperty == null)
                {
                    new SystemException("Please set incremental provision model id");
                }

                Console.WriteLine("Provisioning preparing model");
                var preparingModel = model.GetContainersModel();
                if (incrementalProvisionModelIdProperty != null)
                {
                    preparingModel.SetIncrementalProvisionModelId("Preparing: " + incrementalProvisionModelIdProperty.Value);
                }
                x.DeployModel(SPMeta2.CSOM.ModelHosts.WebModelHost.FromClientContext(Ctx), preparingModel);
                Console.WriteLine();

                Console.WriteLine("Provisioning main model");
                x.DeployModel(SPMeta2.CSOM.ModelHosts.WebModelHost.FromClientContext(Ctx), model);
            });
        }
Example #12
0
 public static WebModelNode AddRandomField(this WebModelNode model, Action <ModelNode> action)
 {
     return(model.AddRandomTypedDefinition <FieldDefinition, WebModelNode, FieldModelNode>(action));
 }
 private static void setupWeb(WebModelNode web, bool AddNintex = false)
 {
     web.AddNintexWorkflowO365(webWorkflow, workflowModel =>
     {
         #region Events
         workflowModel.OnProvisioning <Object>
             (spMetaCtx =>
         {
             Console.WriteLine("About to provision the workflow on the web");
         });
         workflowModel.OnProvisioned <NintexO365HandlerOnProvisionedEvent>
             (spMetaCtx =>
         {
             Console.WriteLine("Provisoined the workflow for {0}", ((NintexWebWorkflowO365Definition)spMetaCtx.ObjectDefinition).Name);
             var result = spMetaCtx.Object;
             if (result.saveResponse != null)
             {
                 Console.WriteLine("The result of save is {0}", result.saveResponse.Content.ReadAsStringAsync().Result);
             }
             if (result.puiblishResponse != null)
             {
                 Console.WriteLine("The result of publish is {0}", result.puiblishResponse.Content.ReadAsStringAsync().Result);
             }
             if (result.assignedUseForProductionValue != null)
             {
                 Console.WriteLine("The result of assigned use is {0}", result.assignedUseForProductionValue.Content.ReadAsStringAsync().Result);
             }
         });
         #endregion
     });
     web.AddList(TestList, list =>
     {
         list.AddContentTypeLink(BuiltInContentTypeId.Issue);
         // this refers to SPMeta2.NintexExt.Core.Syntax.Default;
         if (AddNintex)
         {
             list.AddNintexFormO365(form, formmodel =>
             {
                 #region Events
                 formmodel.OnProvisioning <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("About to provision the form for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                 });
                 formmodel.OnProvisioned <NintexO365HandlerOnProvisionedEvent>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("Provisoined the form for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                     var result = spMetaCtx.Object;
                     if (result.saveResponse != null)
                     {
                         Console.WriteLine("The result of save is {0}", result.saveResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.puiblishResponse != null)
                     {
                         Console.WriteLine("The result of publish is {0}", result.puiblishResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.assignedUseForProductionValue != null)
                     {
                         Console.WriteLine("The result of assigned use is {0}", result.assignedUseForProductionValue.Content.ReadAsStringAsync().Result);
                     }
                 });
                 #endregion
             });
             // if you do not use the syntax default, you can use the line below
             //list.AddDefinitionNode(form);
             list.AddNintexWorkflowO365(listWorkflow, listWorkflow =>
             {
                 #region Events
                 listWorkflow.OnProvisioning <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("About to provision the list workflow");
                 });
                 listWorkflow.OnProvisioned <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("Provisoined the list workflow");
                 });
                 //TODO:
                 //listWorkflow.OnProvisioned<NintexFormO365HandlerOnProvisionedEvent>
                 //    (spMetaCtx =>
                 //    {
                 //        Console.WriteLine("Provisoined the workflow m for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                 //        var result = spMetaCtx.Object;
                 //        if (result.saveResponse != null)
                 //        {
                 //            Console.WriteLine("The result of save is {0}", result.saveResponse.Content.ReadAsStringAsync().Result);
                 //        }
                 //        if (result.puiblishResponse != null)
                 //        {
                 //            Console.WriteLine("The result of publish is {0}", result.puiblishResponse.Content.ReadAsStringAsync().Result);
                 //        }
                 //        if (result.assignedUseForProductionValue != null)
                 //        {
                 //            Console.WriteLine("The result of assigned use is {0}", result.assignedUseForProductionValue.Content.ReadAsStringAsync().Result);
                 //        }
                 //    });
                 #endregion
             });
         }
     });
     // same here, same list, testing that it works when the list is already there
     web.AddHostList(TestList, list =>
     {
         if (AddNintex)
         {
             // this refers to SPMeta2.NintexExt.Core.Syntax.Default;
             list.AddNintexFormO365(form, formmodel =>
             {
                 #region Events
                 formmodel.OnProvisioning <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("About to provision the form for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                 });
                 formmodel.OnProvisioned <NintexO365HandlerOnProvisionedEvent>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("Provisoined the form for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                     var result = spMetaCtx.Object;
                     if (result.saveResponse != null)
                     {
                         Console.WriteLine("The result of save is {0}", result.saveResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.puiblishResponse != null)
                     {
                         Console.WriteLine("The result of publish is {0}", result.puiblishResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.assignedUseForProductionValue != null)
                     {
                         Console.WriteLine("The result of assigned use is {0}", result.assignedUseForProductionValue.Content.ReadAsStringAsync().Result);
                     }
                 });
                 #endregion
             });
             // if you do not use the syntax default, you can use the line below
             //list.AddDefinitionNode(form);
             list.AddNintexWorkflowO365(listWorkflow, listWorkflow =>
             {
                 #region Events
                 listWorkflow.OnProvisioning <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("About to provision the list workflow");
                 });
                 listWorkflow.OnProvisioned <NintexO365HandlerOnProvisionedEvent>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("Provisoined the workflow m for {0}", ((NintexListWorkflowO365Definition)spMetaCtx.ObjectDefinition).Name);
                     var result = spMetaCtx.Object;
                     if (result.saveResponse != null)
                     {
                         Console.WriteLine("The result of save is {0}", result.saveResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.puiblishResponse != null)
                     {
                         Console.WriteLine("The result of publish is {0}", result.puiblishResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.assignedUseForProductionValue != null)
                     {
                         Console.WriteLine("The result of assigned use is {0}", result.assignedUseForProductionValue.Content.ReadAsStringAsync().Result);
                     }
                 });
                 #endregion
             });
         }
     });
     web.AddList(TestList2, list =>
     {
         list.AddContentTypeLink(BuiltInContentTypeId.Issue);
         // this refers to SPMeta2.NintexExt.Core.Syntax.Default;
         if (AddNintex)
         {
             list.AddNintexFormO365(form2_item, formmodel =>
             {
                 #region Events
                 formmodel.OnProvisioning <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("About to provision the form for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                 });
                 formmodel.OnProvisioned <NintexO365HandlerOnProvisionedEvent>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("Provisoined the form for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                     var result = spMetaCtx.Object;
                     if (result.saveResponse != null)
                     {
                         Console.WriteLine("The result of save is {0}", result.saveResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.puiblishResponse != null)
                     {
                         Console.WriteLine("The result of publish is {0}", result.puiblishResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.assignedUseForProductionValue != null)
                     {
                         Console.WriteLine("The result of assigned use is {0}", result.assignedUseForProductionValue.Content.ReadAsStringAsync().Result);
                     }
                 });
                 #endregion
             });
             list.AddNintexFormO365(form2_issue, formmodel =>
             {
                 #region Events
                 formmodel.OnProvisioning <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("About to provision the form for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                 });
                 formmodel.OnProvisioned <NintexO365HandlerOnProvisionedEvent>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("Provisoined the form for {0}", ((NintexFormO365Definition)spMetaCtx.ObjectDefinition).ListContentTypeNameOrId);
                     var result = spMetaCtx.Object;
                     if (result.saveResponse != null)
                     {
                         Console.WriteLine("The result of save is {0}", result.saveResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.puiblishResponse != null)
                     {
                         Console.WriteLine("The result of publish is {0}", result.puiblishResponse.Content.ReadAsStringAsync().Result);
                     }
                     if (result.assignedUseForProductionValue != null)
                     {
                         Console.WriteLine("The result of assigned use is {0}", result.assignedUseForProductionValue.Content.ReadAsStringAsync().Result);
                     }
                 });
                 #endregion
             });
             list.AddNintexWorkflowO365(listWorkflow2, listWorkflow =>
             {
                 #region Events
                 listWorkflow.OnProvisioning <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("About to provision the list workflow 2");
                 });
                 listWorkflow.OnProvisioned <Object>
                     (spMetaCtx =>
                 {
                     Console.WriteLine("Provisoined the list workflow 2");
                 });
                 #endregion
             });
         }
     });
 }
Example #14
0
 public static WebModelNode AddRandomList(this WebModelNode model, Action <ListModelNode> action)
 {
     return(model.AddRandomTypedDefinition <ListDefinition, WebModelNode, ListModelNode>(action));
 }
Example #15
0
 public static WebModelNode AddRandomApp(this WebModelNode model, Action<WebModelNode> action)
 {
     return model.AddRandomTypedDefinition<AppDefinition, WebModelNode, WebModelNode>(action);
 }
Example #16
0
        protected virtual void FillWebWithTheTestwebPartSuite <TWebpartType>(WebModelNode currentWeb)
            where TWebpartType : WebPartDefinitionBase, new()
        {
            var initialDef = ModelGeneratorService.GetRandomDefinition(typeof(TWebpartType)) as TWebpartType;

            var wikiWebPartDef           = initialDef.Clone <TWebpartType>();
            var webpartPageWebPartDef    = initialDef.Clone <TWebpartType>();
            var publishingPageWebPartDef = initialDef.Clone <TWebpartType>();

            var listWebPartDef = initialDef.Clone <TWebpartType>();
            var docWebPartDef  = initialDef.Clone <TWebpartType>();

            // ensure for the client web part
            currentWeb.AddRandomApp();

            currentWeb
            /// for the Pages lib & pubnlishing pages
            .AddWebFeature(BuiltInWebFeatures.SharePointServerPublishing.Inherit(def =>
            {
                def.Enable = true;
            }))

            .AddHostList(BuiltInListDefinitions.SitePages, list =>
            {
                var webpartPageName = string.Empty;
                var wikiPageName    = string.Empty;

                list
                // 1 - wiki pages
                .AddRandomWikiPage(page =>
                {
                    wikiPageName = (page.Value as WikiPageDefinition).FileName;
                    page.AddDefinitionNode(wikiWebPartDef);
                })
                // 2- web part pages
                .AddRandomWebPartPage(page =>
                {
                    webpartPageName = (page.Value as WebPartPageDefinition).FileName;
                    page.AddDefinitionNode(webpartPageWebPartDef);
                });

                ValidateWebPartPresenceForPage(list, wikiPageName, wikiWebPartDef);
                ValidateWebPartPresenceForPage(list, webpartPageName, webpartPageWebPartDef);
            })
            // 3 - publishing pages
            .AddHostList(BuiltInListDefinitions.Pages, list =>
            {
                var publishingPageName = string.Empty;

                list
                .AddRandomPublishingPage(page =>
                {
                    (page.Value as PublishingPageDefinition).PageLayoutFileName =
                        BuiltInPublishingPageLayoutNames.BlankWebPartPage;
                    publishingPageName = (page.Value as PublishingPageDefinition).FileName;

                    page.AddDefinitionNode(publishingPageWebPartDef);
                });

                ValidateWebPartPresenceForPage(list, publishingPageName, publishingPageWebPartDef);
            })
            // 4 - list related routines - OOTB views, custom views & forms
            .AddRandomList(list =>
            {
                // OOTB view
                list.AddHostListView(BuiltInListViewDefinitions.Lists.AllItems, listView =>
                {
                    listView.AddDefinitionNode(listWebPartDef.Inherit());
                });

                if (ShoudValidatePresenceOnListViews(initialDef))
                {
                    ValidateWebPartPresenceForPage(list, BuiltInListViewDefinitions.Lists.AllItems.Url, listWebPartDef);
                }

                // custom view
                var customView = ModelGeneratorService.GetRandomDefinition <ListViewDefinition>(def =>
                {
                    def.Url = Rnd.AspxFileName();
                });

                list.AddListView(customView, listView =>
                {
                    listView.AddDefinitionNode(listWebPartDef.Inherit());
                });

                if (ShoudValidatePresenceOnListViews(initialDef))
                {
                    ValidateWebPartPresenceForPage(list, customView.Url, listWebPartDef);
                }

                // OOTB forms, new - edit - view
                list.AddHostListView(BuiltInListViewDefinitions.Lists.NewForm, listView =>
                {
                    listView.AddDefinitionNode(listWebPartDef.Inherit());
                });

                ValidateWebPartPresenceForPage(list, BuiltInListViewDefinitions.Lists.NewForm.Url, listWebPartDef);

                list.AddHostListView(BuiltInListViewDefinitions.Lists.EditForm, listView =>
                {
                    listView.AddDefinitionNode(listWebPartDef.Inherit());
                });


                ValidateWebPartPresenceForPage(list, BuiltInListViewDefinitions.Lists.EditForm.Url, listWebPartDef);

                list.AddHostListView(BuiltInListViewDefinitions.Lists.DispForm, listView =>
                {
                    listView.AddDefinitionNode(listWebPartDef.Inherit());
                });


                ValidateWebPartPresenceForPage(list, BuiltInListViewDefinitions.Lists.DispForm.Url, listWebPartDef);
            })

            // 5 - OOTB list view form on the library
            .AddRandomDocumentLibrary(list =>
            {
                // OOTB view

                list.AddHostListView(BuiltInListViewDefinitions.Libraries.AllItems, listView =>
                {
                    listView.AddDefinitionNode(docWebPartDef.Inherit());
                });

                if (ShoudValidatePresenceOnLibraryViews(initialDef))
                {
                    ValidateWebPartPresenceForPage(list, "Forms/" + BuiltInListViewDefinitions.Libraries.AllItems.Url, docWebPartDef);
                }

                // custom view
                var customView = ModelGeneratorService.GetRandomDefinition <ListViewDefinition>(def =>
                {
                    def.Url = Rnd.AspxFileName();
                });

                list.AddListView(customView, listView =>
                {
                    listView.AddDefinitionNode(docWebPartDef.Inherit());
                });

                if (ShoudValidatePresenceOnLibraryViews(initialDef))
                {
                    ValidateWebPartPresenceForPage(list, "Forms/" + customView.Url, docWebPartDef);
                }

                // OOTB new - edit - view forms
                // upload, NOPE!
                //list.AddHostListView(BuiltInListViewDefinitions.Libraries.Upload, listView =>
                //{
                //    listView.AddDefinitionNode(docWebPartDef.Inherit());
                //});

                //ValidateWebPartPresenceForPage(list, "Forms/" + BuiltInListViewDefinitions.Libraries.Upload.Url, docWebPartDef);

                list.AddHostListView(BuiltInListViewDefinitions.Libraries.EditForm, listView =>
                {
                    listView.AddDefinitionNode(docWebPartDef.Inherit());
                });

                ValidateWebPartPresenceForPage(list, "Forms/" + BuiltInListViewDefinitions.Libraries.EditForm.Url, docWebPartDef);

                list.AddHostListView(BuiltInListViewDefinitions.Libraries.DispForm, listView =>
                {
                    listView.AddDefinitionNode(docWebPartDef.Inherit());
                });

                ValidateWebPartPresenceForPage(list, "Forms/" + BuiltInListViewDefinitions.Libraries.DispForm.Url, docWebPartDef);
            });
            ;

            // all web parts chrom
            currentWeb.WithNodesOfType <WebPartDefinitionBase>(node =>
            {
                var wp = node.Value as WebPartDefinitionBase;

                wp.ChromeType  = BuiltInPartChromeType.TitleAndBorder;
                wp.ChromeState = BuiltInPartChromeState.Normal;
            });
        }
Example #17
0
 public static WebModelNode AddRandomWeb(this WebModelNode model)
 {
     return(AddRandomWeb(model, null));
 }
Example #18
0
 public static WebModelNode AddWebFeature(this WebModelNode model, FeatureDefinition definition, Action <FeatureModelNode> action)
 {
     return(AddFeature(model, definition, action));
 }
Example #19
0
 public static WebModelNode SetIncrementalProvisionModelId(this WebModelNode modelNode, string modelId)
 {
     return(InternalSetIncrementalProvisionModelId(modelNode, modelId));
 }
Example #20
0
        protected void FillClientWebPartPages(WebModelNode web)
        {
            web.AddHostPagesList(list =>
            {
                list.AddRandomPublishingPage(page =>
                {
                    page.AddRandomWebpart();
                });
            });

            web.AddHostSitePagesList(list =>
            {
                list.AddRandomWikiPage(page =>
                {
                    page.AddRandomWebpart();
                });

                list.AddRandomWebPartPage(page =>
                {
                    page.AddRandomWebpart();
                });
            });
        }
Example #21
0
        private void AddAndCheckRandomAppWithVersion(WebModelNode web, Version version)
        {
            var def = new AppDefinition();

            def.ProductId = DefaultContainers.Apps.ProductId;
            def.Version = version.ToString();

            def.Content = File.ReadAllBytes(string.Format(DefaultContainers.Apps.GenericVersionableAppFilePath, version));

            web.AddApp(def, app =>
            {
                app.OnProvisioned<object, AppDefinition>(context =>
                {
                    Trace.WriteLine(context.ObjectDefinition.ToString());
                    Trace.WriteLine(context.Object.ToString());

                    var expectedAppVersion = new Version(context.ObjectDefinition.Version);

                    var obj = context.Object;
                    var objType = context.Object.GetType();

                    if (objType.ToString().Contains("Microsoft.SharePoint.Client.AppInstance"))
                    {
                        // with CSOM there is no API to know current app installed version
                        // checking if app is Installed after every single update
                        var appStatus = obj.GetPropertyValue("Status").ToString();

                        Assert.IsTrue(appStatus == "Installed",
                            string.Format("App should be installed after every update"));
                    }
                    else if (objType.ToString().Contains("Microsoft.SharePoint.Administration.SPAppInstance"))
                    {
                        var appObjet = obj.GetPropertyValue("App");

                        var versionString = appObjet.GetPropertyValue("VersionString") as string;
                        var spAppVersion = new Version(versionString);

                        // either equal (update) or SharePoint version greater than local (second update)
                        // the test is run several times, so only once we have =, and then we have <
                        Assert.IsTrue(expectedAppVersion <= spAppVersion,
                            string.Format("Expecting app version:[{0}] SharePoint app version:[{1}]", expectedAppVersion, spAppVersion));
                    }
                    else
                    {
                        throw new SPMeta2NotImplementedException(string.Format("ID property extraction is not implemented for type: [{0}]", objType));
                    }
                });
            });
        }
Example #22
0
        protected virtual void FillWebWithTheTestwebPartSuite <TWebpartType>(WebModelNode currentWeb)
            where TWebpartType : WebPartDefinitionBase, new()
        {
            var initialDef = ModelGeneratorService.GetRandomDefinition(typeof(TWebpartType)) as TWebpartType;

            var wikiWebPartDef           = initialDef.Clone <TWebpartType>();
            var webpartPageWebPartDef    = initialDef.Clone <TWebpartType>();
            var publishingPageWebPartDef = initialDef.Clone <TWebpartType>();

            // Some web part provision on wiki page give empty markup #693
            // https://github.com/SubPointSolutions/spmeta2/issues/693
            var webpartPageWebPartAddToPageContentDef1 = initialDef.Clone <TWebpartType>();

            webpartPageWebPartAddToPageContentDef1.Title            = Rnd.String();
            webpartPageWebPartAddToPageContentDef1.Id               = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_');
            webpartPageWebPartAddToPageContentDef1.ZoneId           = "wpz";
            webpartPageWebPartAddToPageContentDef1.AddToPageContent = true;

            var webpartPageWebPartAddToPageContentDef2 = initialDef.Clone <TWebpartType>();

            webpartPageWebPartAddToPageContentDef2.Title            = Rnd.String();
            webpartPageWebPartAddToPageContentDef2.Id               = "g_" + Guid.NewGuid().ToString("D").Replace('-', '_');
            webpartPageWebPartAddToPageContentDef2.ZoneId           = "wpz";
            webpartPageWebPartAddToPageContentDef2.AddToPageContent = true;

            var listWebPartDef = initialDef.Clone <TWebpartType>();
            var docWebPartDef  = initialDef.Clone <TWebpartType>();

            // ensure for the client web part
            currentWeb.AddRandomApp();

            currentWeb
            /// for the Pages lib & pubnlishing pages
            .AddWebFeature(BuiltInWebFeatures.SharePointServerPublishing.Inherit(def =>
            {
                def.Enable        = true;
                def.ForceActivate = true;
            }))

            .AddHostList(BuiltInListDefinitions.SitePages, list =>
            {
                var webpartPageName = string.Empty;
                var wikiPageName    = string.Empty;
                var wikiPageNameAddToPageContent = string.Empty;

                if (UseWikiPages)
                {
                    list
                    // 1 - wiki pages
                    .AddRandomWikiPage(page =>
                    {
                        wikiPageName = (page.Value as WikiPageDefinition).FileName;
                        page.AddDefinitionNode(wikiWebPartDef);
                    });

                    ValidateWebPartPresenceForPage(list, wikiPageName, wikiWebPartDef);
                }

                if (UseWebPartPages)
                {
                    list
                    // 2- web part pages
                    .AddRandomWebPartPage(page =>
                    {
                        webpartPageName = (page.Value as WebPartPageDefinition).FileName;
                        page.AddDefinitionNode(webpartPageWebPartDef);
                    });

                    ValidateWebPartPresenceForPage(list, webpartPageName, webpartPageWebPartDef);
                }

                if (UseWikiPages)
                {
                    list
                    /// 3- adding to the web part page as .AddToPageContent
                    .AddRandomWikiPage(page =>
                    {
                        page.RegExcludeFromValidation();

                        wikiPageNameAddToPageContent = (page.Value as WikiPageDefinition).FileName;

                        page.AddDefinitionNode(webpartPageWebPartAddToPageContentDef1);
                        page.AddDefinitionNode(webpartPageWebPartAddToPageContentDef2);
                    });

                    ValidateWebPartPresenceForPage(list, wikiPageNameAddToPageContent, webpartPageWebPartAddToPageContentDef1);
                    ValidateWebPartPresenceForPage(list, wikiPageNameAddToPageContent, webpartPageWebPartAddToPageContentDef2);
                }
            });

            // 3 - publishing pages
            currentWeb.AddHostList(BuiltInListDefinitions.Pages, list =>
            {
                var publishingPageName = string.Empty;

                if (UsePublishingPages)
                {
                    list
                    .AddRandomPublishingPage(page =>
                    {
                        (page.Value as PublishingPageDefinition).PageLayoutFileName =
                            BuiltInPublishingPageLayoutNames.BlankWebPartPage;
                        publishingPageName = (page.Value as PublishingPageDefinition).FileName;

                        page.AddDefinitionNode(publishingPageWebPartDef);
                    });

                    ValidateWebPartPresenceForPage(list, publishingPageName, publishingPageWebPartDef);
                }
            });

            if (UseListPages)
            {
                // 4 - list related routines - OOTB views, custom views & forms
                currentWeb.AddRandomList(list =>
                {
                    // OOTB view
                    list.AddHostListView(BuiltInListViewDefinitions.Lists.AllItems, listView =>
                    {
                        listView.AddDefinitionNode(listWebPartDef.Inherit());
                    });

                    if (ShoudValidatePresenceOnListViews(initialDef))
                    {
                        ValidateWebPartPresenceForPage(list, BuiltInListViewDefinitions.Lists.AllItems.Url, listWebPartDef);
                    }

                    // custom view
                    var customView = ModelGeneratorService.GetRandomDefinition <ListViewDefinition>(def =>
                    {
                        def.Url = Rnd.AspxFileName();
                    });

                    list.AddListView(customView, listView =>
                    {
                        listView.AddDefinitionNode(listWebPartDef.Inherit());
                    });

                    if (ShoudValidatePresenceOnListViews(initialDef))
                    {
                        ValidateWebPartPresenceForPage(list, customView.Url, listWebPartDef);
                    }

                    // OOTB forms, new - edit - view
                    list.AddHostListView(BuiltInListViewDefinitions.Lists.NewForm, listView =>
                    {
                        listView.AddDefinitionNode(listWebPartDef.Inherit());
                    });

                    ValidateWebPartPresenceForPage(list, BuiltInListViewDefinitions.Lists.NewForm.Url, listWebPartDef);

                    list.AddHostListView(BuiltInListViewDefinitions.Lists.EditForm, listView =>
                    {
                        listView.AddDefinitionNode(listWebPartDef.Inherit());
                    });


                    ValidateWebPartPresenceForPage(list, BuiltInListViewDefinitions.Lists.EditForm.Url, listWebPartDef);

                    list.AddHostListView(BuiltInListViewDefinitions.Lists.DispForm, listView =>
                    {
                        listView.AddDefinitionNode(listWebPartDef.Inherit());
                    });


                    ValidateWebPartPresenceForPage(list, BuiltInListViewDefinitions.Lists.DispForm.Url, listWebPartDef);
                });
            }

            if (UseLibraryPages)
            {
                // 5 - OOTB list view form on the library
                currentWeb.AddRandomDocumentLibrary(list =>
                {
                    // OOTB view

                    list.AddHostListView(BuiltInListViewDefinitions.Libraries.AllItems, listView =>
                    {
                        listView.AddDefinitionNode(docWebPartDef.Inherit());
                    });

                    if (ShoudValidatePresenceOnLibraryViews(initialDef))
                    {
                        ValidateWebPartPresenceForPage(list, "Forms/" + BuiltInListViewDefinitions.Libraries.AllItems.Url, docWebPartDef);
                    }

                    // custom view
                    var customView = ModelGeneratorService.GetRandomDefinition <ListViewDefinition>(def =>
                    {
                        def.Url = Rnd.AspxFileName();
                    });

                    list.AddListView(customView, listView =>
                    {
                        listView.AddDefinitionNode(docWebPartDef.Inherit());
                    });

                    if (ShoudValidatePresenceOnLibraryViews(initialDef))
                    {
                        ValidateWebPartPresenceForPage(list, "Forms/" + customView.Url, docWebPartDef);
                    }

                    // OOTB new - edit - view forms
                    // upload, NOPE!
                    //list.AddHostListView(BuiltInListViewDefinitions.Libraries.Upload, listView =>
                    //{
                    //    listView.AddDefinitionNode(docWebPartDef.Inherit());
                    //});

                    //ValidateWebPartPresenceForPage(list, "Forms/" + BuiltInListViewDefinitions.Libraries.Upload.Url, docWebPartDef);

                    list.AddHostListView(BuiltInListViewDefinitions.Libraries.EditForm, listView =>
                    {
                        listView.AddDefinitionNode(docWebPartDef.Inherit());
                    });

                    ValidateWebPartPresenceForPage(list, "Forms/" + BuiltInListViewDefinitions.Libraries.EditForm.Url, docWebPartDef);

                    list.AddHostListView(BuiltInListViewDefinitions.Libraries.DispForm, listView =>
                    {
                        listView.AddDefinitionNode(docWebPartDef.Inherit());
                    });

                    ValidateWebPartPresenceForPage(list, "Forms/" + BuiltInListViewDefinitions.Libraries.DispForm.Url, docWebPartDef);
                });
            }
            ;

            // all web parts chrom
            currentWeb.WithNodesOfType <WebPartDefinitionBase>(node =>
            {
                var wp = node.Value as WebPartDefinitionBase;

                wp.ChromeType  = BuiltInPartChromeType.TitleAndBorder;
                wp.ChromeState = BuiltInPartChromeState.Normal;
            });
        }
Example #23
0
 public static WebModelNode AddRandomContentType(this WebModelNode model)
 {
     return(AddRandomContentType(model, null));
 }
        protected void AddWebWorkflow(WebModelNode web)
        {
            var workflow = ModelGeneratorService.GetRandomDefinition<SP2013WorkflowDefinition>();

            var historyList = GetHistoryList();
            var taskList = GetTaskList();

            web
                .AddList(historyList)
                .AddList(taskList)
                .AddSP2013Workflow(workflow)
                .AddSP2013WorkflowSubscription(new SP2013WorkflowSubscriptionDefinition
                {
                    Name = Rnd.String(),
                    WorkflowDisplayName = workflow.DisplayName,
                    HistoryListUrl = historyList.GetListUrl(),
                    TaskListUrl = taskList.GetListUrl()
                });
        }
Example #25
0
 public static WebModelNode AddRandomContentType(this WebModelNode model,
                                                 Action <ContentTypeModelNode> action)
 {
     return(model.AddRandomTypedDefinition <ContentTypeDefinition, WebModelNode, ContentTypeModelNode>(action));
 }
Example #26
0
 public static WebModelNode AddRandomDocumentLibrary(this WebModelNode model)
 {
     return AddRandomDocumentLibrary(model, null);
 }
Example #27
0
 public static WebModelNode AddRandomWeb(this WebModelNode model, Action <WebModelNode> action)
 {
     return(model.AddRandomTypedDefinition <WebDefinition, WebModelNode, WebModelNode>(action));
 }
Example #28
0
 public static WebModelNode AddRandomApp(this WebModelNode model)
 {
     return AddRandomApp(model, null);
 }
Example #29
0
 public static WebModelNode AddWebFeature(this WebModelNode model, FeatureDefinition definition)
 {
     return(AddWebFeature(model, definition, null));
 }
Example #30
0
 public static void DeploySPMetaModel(this ClientContext Ctx, WebModelNode model)
 {
     DeploySPMetaModel(Ctx, model, false);
 }