protected ListItem FindPage(List list, Folder folder, MasterPageDefinition definition)
        {
            var pageName = GetSafePageFileName(definition);
            var file     = GetCurrentPage(list, folder, pageName);

            if (file != null)
            {
                return(file.ListItemAllFields);
            }

            return(null);
        }
        private SPListItem CreateObject(object modelHost, SPFolder folder, MasterPageDefinition definition)
        {
            var pageName    = GetSafePageFileName(definition);
            var fileContent = definition.Content;

            ModuleFileModelHandler.DeployModuleFile(folder,
                                                    SPUrlUtility.CombineUrl(folder.ServerRelativeUrl, pageName),
                                                    pageName,
                                                    fileContent,
                                                    true,
                                                    null,
                                                    null);

            return(GetCurrentObject(folder, definition));
        }
Example #3
0
        //[SampleMetadataTag(Name = BuiltInTagNames.SampleHidden)]
        public void CanDeploySimpleMasterPageDefinition()
        {
            var masterPage = new MasterPageDefinition
            {
                Title    = "M2 Oslo",
                FileName = "m2-oslo.master",
                // replace with your master page content
                Content      = Encoding.UTF8.GetBytes(DefaultMasterPageTemplates.Oslo),
                NeedOverride = true
            };

            var model = SPMeta2Model.NewWebModel(web =>
            {
                web.AddHostList(BuiltInListDefinitions.Catalogs.MasterPage, list =>
                {
                    list.AddMasterPage(masterPage);
                });
            });

            DeployModel(model);
        }
        public override ModelNode ReverseSingleHost(object reverseHost, ReverseOptions options)
        {
            var item    = (reverseHost as MasterPageReverseHost).HostMasterPageFile;
            var context = (reverseHost as MasterPageReverseHost).HostClientContext;

            var def = new MasterPageDefinition();

            def.FileName = item.Name;
            def.Title    = item.Title;

            using (var stream = File.OpenBinaryDirect(
                       context,
                       item.ServerRelativeUrl).Stream)
            {
                def.Content = ModuleFileUtils.ReadFully(stream);
            }

            return(new MasterPageModelNode
            {
                Options = { RequireSelfProcessing = true },
                Value = def
            });
        }
 public static ModelNode AddMasterPage(this ModelNode model, MasterPageDefinition definition, Action <ModelNode> action)
 {
     return(model.AddDefinitionNode(definition, action));
 }
 public static ModelNode AddMasterPage(this ModelNode model, MasterPageDefinition definition)
 {
     return(AddMasterPage(model, definition, null));
 }
        private void DeployPage(object modelHost, SPList list, SPFolder folder, MasterPageDefinition definition)
        {
            var web        = list.ParentWeb;
            var targetPage = GetCurrentObject(folder, definition);

            InvokeOnModelEvent(this, new ModelEventArgs
            {
                CurrentModelNode = null,
                Model            = null,
                EventType        = ModelEventType.OnProvisioning,
                Object           = targetPage == null ? null : targetPage.File,
                ObjectType       = typeof(SPFile),
                ObjectDefinition = definition,
                ModelHost        = modelHost
            });

            if (targetPage == null)
            {
                targetPage = CreateObject(modelHost, folder, definition);
            }

            InvokeOnModelEvent(this, new ModelEventArgs
            {
                CurrentModelNode = null,
                Model            = null,
                EventType        = ModelEventType.OnProvisioned,
                Object           = targetPage.File,
                ObjectType       = typeof(SPFile),
                ObjectDefinition = definition,
                ModelHost        = modelHost
            });

            ModuleFileModelHandler.WithSafeFileOperation(list, folder,
                                                         targetPage.Url,
                                                         GetSafePageFileName(definition),
                                                         definition.Content,
                                                         definition.NeedOverride,
                                                         null,
                                                         afterFile =>
            {
                var pageItem = afterFile.Properties;

                //pageItem[BuiltInInternalFieldNames.Title] = definition.Title;
                pageItem["vti_title"]             = definition.Title;
                pageItem["MasterPageDescription"] = definition.Description;
                pageItem[BuiltInInternalFieldNames.ContentTypeId] = BuiltInContentTypeId.MasterPage;

                if (definition.UIVersion.Count > 0)
                {
                    var value = new SPFieldMultiChoiceValue();

                    foreach (var v in definition.UIVersion)
                    {
                        value.Add(v);
                    }

                    pageItem["UIVersion"] = value.ToString();
                }

                pageItem["DefaultCssFile"] = definition.DefaultCSSFile;

                //pageItem.Update();

                //pageItem.SystemUpdate();
            });
        }
        protected File FindPageFile(List list, Folder folder, MasterPageDefinition definition)
        {
            var pageName = GetSafePageFileName(definition);

            return(GetCurrentPage(list, folder, pageName));
        }
 public static TModelNode AddMasterPage <TModelNode>(this TModelNode model, MasterPageDefinition definition,
                                                     Action <MasterPageModelNode> action)
     where TModelNode : ModelNode, IListItemHostModelNode, new()
 {
     return(model.AddTypedDefinitionNode(definition, action));
 }
 public static TModelNode AddMasterPage <TModelNode>(this TModelNode model, MasterPageDefinition definition)
     where TModelNode : ModelNode, IListItemHostModelNode, new()
 {
     return(AddMasterPage(model, definition, null));
 }