/// <summary> /// A site was provisioned. /// </summary> public override void WebProvisioned(SPWebEventProperties properties) { base.WebProvisioned(properties); SPSite siteCollection = properties.Web.Site; SPWeb subSite = properties.Web; if (!subSite.WebTemplate.Contains("APP")) { Guid sitePublishingGuid = new Guid("f6924d36-2fa8-4f0b-b16d-06b7250180fa"); Guid webPublishingGuid = new Guid("94c94ca6-b32f-4da9-a9e3-1f3d343d7ecb"); EnsureSiteFeatureActivated(sitePublishingGuid, siteCollection); EnsureWebFeatureActivated(webPublishingGuid, siteCollection, subSite); var pubWeb = PublishingWeb.GetPublishingWeb(subSite); var webNavigationSettings = new Microsoft.SharePoint.Publishing.Navigation.WebNavigationSettings(subSite); webNavigationSettings.GlobalNavigation.Source = Microsoft.SharePoint.Publishing.Navigation.StandardNavigationSource.InheritFromParentWeb; webNavigationSettings.CurrentNavigation.Source = Microsoft.SharePoint.Publishing.Navigation.StandardNavigationSource.PortalProvider; webNavigationSettings.Update(); pubWeb.Update(); subSite.MasterUrl = siteCollection.RootWeb.MasterUrl; subSite.CustomMasterUrl = siteCollection.RootWeb.CustomMasterUrl; subSite.SiteLogoUrl = siteCollection.RootWeb.SiteLogoUrl; subSite.Update(); } }
public override void FeatureActivated(SPFeatureReceiverProperties properties) { SPSite site = properties.Feature.Parent as SPSite; PublishingWeb pWeb = PublishingWeb.GetPublishingWeb(site.RootWeb); bool pageNotCreated = !pWeb.GetPublishingPages().Cast <PublishingPage>().Any(p => p.Name == pageName); if (pageNotCreated) { //если такой страницы еще нет - создаем ее PublishingPage pPage = pWeb.GetPublishingPages().Add(pageName, null); pPage.CheckOut(); using (Microsoft.SharePoint.WebPartPages.SPLimitedWebPartManager wpManager = site.RootWeb.GetLimitedWebPartManager(pPage.Url, PersonalizationScope.Shared)) { ResultScriptWebPart searchResults = GetImportedWebPart(site, wpName) as ResultScriptWebPart; searchResults.Title = wpTitle; searchResults.ChromeType = PartChromeType.None; wpManager.AddWebPart(searchResults, "Top", 0); } pPage.CheckIn(string.Empty); } }
public override void FeatureActivated(SPFeatureReceiverProperties properties) { SPWeb web = properties.Feature.Parent as SPWeb; //if the web of type MLGSchool, set its MasterURL and Custom MasterURl if (string.Compare(web.WebTemplate, "MLGSchool", true) == 0) { try { string masterURL = web.ServerRelativeUrl + masterPageName; web.MasterUrl = masterURL; web.CustomMasterUrl = masterURL; web.Update(); } catch { } } else { //in case this is not a school site, check if it is a publishing web, //and if so set the MasterURL, and customMusterURl to inherit from the parent site. try { if (PublishingWeb.IsPublishingWeb(web)) { PublishingWeb pWeb = PublishingWeb.GetPublishingWeb(web); pWeb.MasterUrl.SetInherit(true, true); pWeb.CustomMasterUrl.SetInherit(true, true); pWeb.Update(); } } catch { } } }
private void CreatePartnerTabbedPage(SPWeb web, SPList sitesList) { // Create a new page for listing Partner Site Collections if (PublishingWeb.IsPublishingWeb(web)) { PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(web); PublishingPageCollection availablePages = pubWeb.GetPublishingPages(); PublishingPage partnerSitesPage = availablePages[Constants.PartnerSitesPageUrl]; if (partnerSitesPage == null) { // The Partner Sites page should be based on the same layout as the top sites page. PublishingPage topSitesPage = availablePages[Constants.TopSitesPageUrl]; partnerSitesPage = availablePages.Add(Constants.PartnerSitesFileName, topSitesPage.Layout); partnerSitesPage.ListItem[titleFieldId] = Constants.PartnerSitesTile; // We can not use the Field Id of the the Description field, because it is not static. partnerSitesPage.ListItem[Constants.DescriptionField] = Resources.PartnerSitePageDescription; partnerSitesPage.Update(); SPFile partnerSitesPageFile = web.GetFile(partnerSitesPage.Url); AddListViewWebPartToPage(sitesList, partnerSitesPage, partnerSitesPageFile); // Add a tab to the Tabs control. SPListItem newTab = web.Lists[Constants.TabsList].Items.Add(); newTab[Constants.TabNameField] = Constants.PartnersTabName; newTab[Constants.PageField] = Constants.PartnerSitesFileName; newTab[Constants.TooltipField] = Constants.PartnerSitesTooltip; newTab.Update(); } } }
// Uncomment the method below to handle the event raised before a feature is deactivated. public override void FeatureDeactivating(SPFeatureReceiverProperties properties) { SPSite siteCollection = properties.Feature.Parent as SPSite; if (siteCollection != null) { SPWeb topLevelSite = siteCollection.RootWeb; String WebAppRelativePath = topLevelSite.ServerRelativeUrl; if (!WebAppRelativePath.EndsWith("/")) { WebAppRelativePath += "/"; } foreach (SPWeb site in siteCollection.AllWebs) { if (!site.WebTemplate.Contains("APP")) { var pubWeb = PublishingWeb.GetPublishingWeb(site); var webNavigationSettings = new Microsoft.SharePoint.Publishing.Navigation.WebNavigationSettings(site); webNavigationSettings.GlobalNavigation.Source = Microsoft.SharePoint.Publishing.Navigation.StandardNavigationSource.PortalProvider; webNavigationSettings.CurrentNavigation.Source = Microsoft.SharePoint.Publishing.Navigation.StandardNavigationSource.PortalProvider; webNavigationSettings.Update(); pubWeb.Update(); site.MasterUrl = WebAppRelativePath + "_catalogs/masterpage/seattle.master"; site.CustomMasterUrl = WebAppRelativePath + "_catalogs/masterpage/seattle.master"; site.SiteLogoUrl = ""; site.Update(); } } } }
private void DeployDefinition(object modelHost, WebModelHost webModelHost, PageLayoutAndSiteTemplateSettingsDefinition definition) { var web = webModelHost.HostWeb; var publishingWeb = PublishingWeb.GetPublishingWeb(web); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioning, Object = web, ObjectType = typeof(SPWeb), ObjectDefinition = definition, ModelHost = modelHost }); ProcessWebTemplateSettings(publishingWeb, definition); ProcessPageLayoutSettings(publishingWeb, definition); ProcessNewPageDefaultSettings(publishingWeb, definition); ProcessConverBlankSpacesIntoHyphenSetting(publishingWeb, definition); InvokeOnModelEvent(this, new ModelEventArgs { CurrentModelNode = null, Model = null, EventType = ModelEventType.OnProvisioned, Object = web, ObjectType = typeof(SPWeb), ObjectDefinition = definition, ModelHost = modelHost }); publishingWeb.Update(); }
protected override IEnumerable <PageLayout> RetrieveDataObjects() { List <PageLayout> layouts = new List <PageLayout>(); SPWeb web = null; if (Web != null) { web = Web.Read(); if (!PublishingWeb.IsPublishingWeb(web)) { throw new ArgumentException("The specified web is not a publishing web."); } AssignmentCollection.Add(web); AssignmentCollection.Add(web.Site); } switch (ParameterSetName) { case "PageLayout": foreach (SPPageLayoutPipeBind pipeBind in PageLayout) { PageLayout layout = pipeBind.Read(web); SPContentType ct1 = null; if (AssociatedContentType != null) { ct1 = AssociatedContentType.Read(layout.ListItem.Web); } if (ct1 == null || ct1.Id == layout.AssociatedContentType.Id) { WriteResult(layout); } } break; case "SPWeb": PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(web); SPContentType ct2 = null; if (AssociatedContentType != null) { ct2 = AssociatedContentType.Read(web); } if (ct2 == null) { WriteResult(pubWeb.GetAvailablePageLayouts()); } else { WriteResult(pubWeb.GetAvailablePageLayouts(ct2.Id)); } break; default: break; } return(null); }
/// <summary> /// Establece la Página de bienveniva de un sitiio /// </summary> /// <param name="web">Objeto SPWeb </param> /// <param name="welcomePage"> Url de la página de bienvenida</param> /// <returns></returns> public static bool SetWelcomePage(this SPWeb web, string welcomePage) { var result = true; try { if (PublishingWeb.IsPublishingWeb(web)) { var publishingWeb = PublishingWeb.GetPublishingWeb(web); var homeFile = web.GetFile(welcomePage); publishingWeb.DefaultPage = homeFile; publishingWeb.Update(); } else { web.RootFolder.WelcomePage = welcomePage; } web.Update(); } catch (Exception) { result = false; } return(result); }
private void PollPublishingWebActivated(string webUrl, int delay = 0) { bool poll = false; SPSecurity.RunWithElevatedPrivileges(delegate() { //TraceLogger.TraceInfo("Checking for PublishingWeb at '{0}' (attempt {1})", webUrl, attempt); using (SPSite site = new SPSite(webUrl)) using (SPWeb newWeb = site.OpenWeb()) { if (PublishingWeb.IsPublishingWeb(newWeb)) { PublishingSite pubSite = new PublishingSite(site); var pubWeb = PublishingWeb.GetPublishingWeb(newWeb); SPList pages = null; try { pages = pubWeb.PagesList; } catch { } if (pages != null) { pages.EnableModeration = false; pages.EnableVersioning = true; pages.EnableMinorVersions = false; pages.MajorVersionLimit = 5; pages.ForceCheckout = false; pages.Update(); } if (OnPublishingWebActivated != null) { OnPublishingWebActivated(newWeb, pubSite, pubWeb); } if (OnPublishingActivated != null) { OnPublishingActivated(webUrl); } } else { //TraceLogger.TraceInfo("Web at '{0}' IS NOT a publishing Web (yet)!", webUrl); poll = delay < PUBLISHING_MAX_DELAY; } } }); if (poll) { Timer timer = new System.Timers.Timer(POLL_SPEED); timer.AutoReset = false; timer.Elapsed += delegate { PollPublishingWebActivated(webUrl, delay += POLL_SPEED); }; timer.Enabled = true; } }
// method for creating publising page private string CreatePublishingPage(string pageName, string pageLayoutName, bool isLandingPage) { string createdPageURL = string.Empty; // elevated privilages as not all user will have permission to create a new page SPSecurity.RunWithElevatedPrivileges(delegate() { // get current web SPWeb oWeb = SPContext.Current.Web; string fullPageUrl = string.Empty; PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(oWeb); /* Get the publishing web page collection list. */ PublishingPageCollection publishingPageCollection = publishingWeb.GetPublishingPages(); //GetPageLayoutName(application); if (!string.IsNullOrEmpty(pageLayoutName)) { /* Search for the page layout for creating the new page */ List <PageLayout> layouts = new List <PageLayout>(publishingWeb.GetAvailablePageLayouts()); PageLayout pageLayout = layouts.Find( delegate(PageLayout l) { return(l.Name.Equals(pageLayoutName, StringComparison.CurrentCultureIgnoreCase)); }); /*page layout exists*/ if (pageLayout != null) { PublishingPage newPage = null; newPage = publishingPageCollection.Add(pageName + ".aspx", pageLayout); newPage.Title = pageName; newPage.Update(); SPList li = newPage.ListItem.ParentList; if (li.EnableModeration == false) { li.EnableModeration = true; li.Update(); } newPage.CheckIn("page checked in"); newPage.ListItem.File.Publish("page published"); newPage.ListItem.File.Approve("page approved"); /* Set newly created page as a welcome page */ if (isLandingPage == true) { fullPageUrl = oWeb.Url + "/Pages/" + pageName + ".aspx"; SPFile fileNew = publishingWeb.Web.GetFile(fullPageUrl); publishingWeb.DefaultPage = fileNew; } publishingWeb.Update(); createdPageURL = newPage.Uri.AbsoluteUri.ToString(); } } }); // return new page url return(createdPageURL); }
public static void AllowPageLayouts(SPSite site, bool allow, params string[] pageLayouts) { var publishingWeb = PublishingWeb.GetPublishingWeb(site.RootWeb); if (publishingWeb != null) { if (allow) { var pageLayoutList = new ArrayList(); var pSite = publishingWeb.Web.Site; if (pSite != null) { var publishingSite = new PublishingSite(pSite); var pageLayoutsCollection = publishingSite.GetPageLayouts(true); foreach (var pl in pageLayoutsCollection) { if ( pageLayouts.ToList() .Any(p => pl.ServerRelativeUrl.ToLower().Contains(p.ToLower()))) { pageLayoutList.Add(pl); } } var newPls = (PageLayout[])pageLayoutList.ToArray(typeof(PageLayout)); publishingWeb.SetAvailablePageLayouts(newPls, false); publishingWeb.Update(); } } else { var availablePageLayouts = publishingWeb.GetAvailablePageLayouts(); var pageLayoutList = new ArrayList(); pageLayoutList.AddRange(availablePageLayouts); var pSite = publishingWeb.Web.Site; if (pSite != null) { var publishingSite = new PublishingSite(pSite); var pageLayoutsCollection = publishingSite.GetPageLayouts(true); foreach (PageLayout pl in pageLayoutsCollection) { if ( pageLayouts.ToList() .Any(p => pl.ServerRelativeUrl.ToLower().Contains(p.ToLower()))) { if (pageLayoutList.Contains(pl)) { pageLayoutList.Remove(pl); } } } var newPls = (PageLayout[])pageLayoutList.ToArray(typeof(PageLayout)); publishingWeb.SetAvailablePageLayouts(newPls, false); publishingWeb.Update(); } } } }
private void AddResultsForSPWeb(SPSite site, SPWeb web) { WBLogging.RecordsTypes.Verbose("In AddResultsForSPWeb(): looking at SPWeb: " + web.Url); try { PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(web); foreach (PublishingPage page in pubWeb.GetPublishingPages()) { WBLogging.RecordsTypes.Verbose("In AddResultsForSPWeb(): page = " + page.WBxToString()); if (page != null) { AddResultsForPublishingPage(page); WBLogging.RecordsTypes.Verbose("InAddResultsForSPWeb() just finished for AddResultsForPublishingPage(): page = " + page.Name); } } } catch (Exception e) { WBLogging.RecordsTypes.Verbose("In FindWhereRecordIsBeingUsed.AddResultsForSPWeb(): This SPWeb is probably not a publishing site: " + web.Url); StringBuilder command = new StringBuilder(); command.Append("<script type=\"text/javascript\">errorProcessingPage(\"").Append(web.Url).Append("\", \"An exception occured at an SPWeb level: ").Append(e.Message).Append("\");</script>\n"); command.Append("<!-- Full exception stack using ToString(): "); command.Append(e.ToString()).Append("-->\n\n"); command.Append("<!-- Full exception stack using FlattenException(): "); command.Append(FlattenException(e)).Append("-->\n\n"); Response.Write(command.ToString()); Response.Flush(); } WBLogging.RecordsTypes.Verbose("InAddResultsForSPWeb() about to look at sub webs for SPWeb: " + web.Url); foreach (SPWeb subWeb in web.Webs) { if (subWeb != null) { WBLogging.RecordsTypes.Verbose("InAddResultsForSPWeb() for a sub SPWeb: " + subWeb.Url); AddResultsForSPWeb(site, subWeb); WBLogging.RecordsTypes.Verbose("InAddResultsForSPWeb() returned from AddResultsForSPWeb for:" + subWeb.Url); subWeb.Dispose(); } else { WBLogging.RecordsTypes.Verbose("InAddResultsForSPWeb() subweb was null:"); } } }
public static void EnsurePublishingWorkflows(SPWeb web, bool useSAMLWorkflow, bool remove) { if (PublishingWeb.IsPublishingWeb(web)) { PublishingWeb pubweb = PublishingWeb.GetPublishingWeb(web); if (pubweb != null) { string listNames = GlobalSettingsHelper.GetValue(ListConstants.EnablePublishingApprovalWorkflowOnLists); if (!string.IsNullOrEmpty(listNames)) { string[] lists = listNames.ToLower().Split(new char[] { ',' }); foreach (string listName in lists) { SPList list = null; switch (listName) { case ("pages"): list = pubweb.PagesList; break; case ("images"): list = pubweb.ImagesLibrary; break; case ("documents"): list = pubweb.DocumentsLibrary; break; } if (list != null) { if (remove) { WorkflowHelper2013.RemoveApprovalWorkflowOnList(web, list, useSAMLWorkflow); } else { List <WorkflowHelper2013.WorkflowStartEventType> events = new List <WorkflowHelper2013.WorkflowStartEventType>() { WorkflowHelper2013.WorkflowStartEventType.Manual }; WorkflowHelper2013.EnsureApprovalWorkflowOnList(web, list, events, useSAMLWorkflow); } } } } } } else { throw new SPException("This feature can only be enabled on a Publishing Web. However you can configure the approval workflows thru list workflow settings."); } }
public static void CreatePublishingPage(ClientContext ctx, string pageName, string pageLayoutName) { var pubWeb = PublishingWeb.GetPublishingWeb(ctx, ctx.Web); var pageInfo = new PublishingPageInformation(); pageInfo.Name = pageName; pageInfo.PageLayoutListItem = GetPageLayout(ctx, pageLayoutName); var publishingPage = pubWeb.AddPublishingPage(pageInfo); ctx.ExecuteQuery(); }
public List <string> GetAllPagesInWeb(SPWeb web) { if (PublishingWeb.IsPublishingWeb(web)) { return(GetAllPublishingPages(PublishingWeb.GetPublishingWeb(web))); } else { return(GetAllPagesFromRoot(web)); } }
private void InitializeObject(SPWeb web) { SPSite cachedSuperUserSite = null; if (HttpContext.Current != null) { cachedSuperUserSite = HttpContext.Current.Items["SuperUserSite"] as SPSite; if (cachedSuperUserSite != null && cachedSuperUserSite.ID != web.Site.ID) { HttpContext.Current.Items["SuperUserSite"] = null; } } try { if (PublishingWeb.IsPublishingWeb(web)) { PublishingWeb currentWeb = PublishingWeb.GetPublishingWeb(web); VariationLabel currentLabel = GetVariationLabel(currentWeb); if (currentLabel != null) { this.IsVariationWeb = true; this.IsSource = currentLabel.IsSource; this.TopWebServerRelativeUrl = new Uri(currentLabel.TopWebUrl).AbsolutePath; this.VariationLabel = currentLabel.Title; this.PagesListName = currentWeb.PagesListName; int lcid; if (Int32.TryParse(currentLabel.Locale, out lcid)) { this.Culture = CultureInfo.GetCultureInfo(lcid); } else { this.Culture = CultureInfo.GetCultureInfo(currentLabel.Language); } } } if (!this.IsVariationWeb) { this.TopWebServerRelativeUrl = web.Site.ServerRelativeUrl; this.VariationLabel = String.Empty; this.PagesListName = "Pages"; this.Culture = web.UICulture; } } finally { // avoid messing up calls to publishing web API in the same HTTP request (FileNotFoundException) // where SuperUserSite should be reserved for current site collection // https://sharepoint.stackexchange.com/questions/83242 if (HttpContext.Current != null && (cachedSuperUserSite == null || cachedSuperUserSite.ID != web.Site.ID)) { HttpContext.Current.Items["SuperUserSite"] = cachedSuperUserSite; } } }
/// <summary> /// Creates the publishing page asynchronous. /// </summary> /// <param name="layoutRelativeUrl">The layout relative URL.</param> /// <param name="pageNameWithExtension">The page name with extension.</param> /// <returns></returns> public async Task <PublishingPage> CreatePublishingPageAsync(string layoutRelativeUrl, string pageNameWithExtension) { var layoutItem = await GetPageLayoutItemAsync(layoutRelativeUrl); var publishingWeb = PublishingWeb.GetPublishingWeb(_ctx, _web); var page = publishingWeb.AddPublishingPage(new PublishingPageInformation { Name = pageNameWithExtension, PageLayoutListItem = layoutItem }); await _ctx.ExecuteQueryAsync(); return(page); }
public static void CreatePublishingPage(ClientContext clientContext, string pageName, string pagelayoutname, string url, string queryurl) { var publishingPageName = pageName + ".aspx"; Web web = clientContext.Web; clientContext.Load(web); List pages = web.Lists.GetByTitle("Pages"); clientContext.Load(pages.RootFolder, f => f.ServerRelativeUrl); clientContext.ExecuteQuery(); Microsoft.SharePoint.Client.File file = web.GetFileByServerRelativeUrl(pages.RootFolder.ServerRelativeUrl + "/" + pageName + ".aspx"); clientContext.Load(file, f => f.Exists); clientContext.ExecuteQuery(); if (file.Exists) { file.DeleteObject(); clientContext.ExecuteQuery(); } PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(clientContext, web); clientContext.Load(publishingWeb); if (publishingWeb != null) { List publishingLayouts = clientContext.Site.RootWeb.Lists.GetByTitle("Master Page Gallery"); ListItemCollection allItems = publishingLayouts.GetItems(CamlQuery.CreateAllItemsQuery()); clientContext.Load(allItems, items => items.Include(item => item.DisplayName).Where(obj => obj.DisplayName == pagelayoutname)); clientContext.ExecuteQuery(); ListItem layout = allItems.Where(x => x.DisplayName == pagelayoutname).FirstOrDefault(); clientContext.Load(layout); PublishingPageInformation publishingpageInfo = new PublishingPageInformation() { Name = publishingPageName, PageLayoutListItem = layout, }; PublishingPage publishingPage = publishingWeb.AddPublishingPage(publishingpageInfo); publishingPage.ListItem.File.CheckIn(string.Empty, CheckinType.MajorCheckIn); publishingPage.ListItem.File.Publish(string.Empty); clientContext.ExecuteQuery(); } SetSupportCaseContent(clientContext, "SupportCasesPage", url, queryurl); }
private static string ExportToXml(ISharePointCommandContext context, PublishingPageInfo pageInfo) { string pageXml = null; PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(context.Web); PublishingPage page = publishingWeb.GetPublishingPage(pageInfo.ServerRelativeUrl); if (page != null) { pageXml = ExportPublishingPage(page, context.Web, context).ToString(); } return(pageXml); }
private static Dictionary <string, string> GetProperties(ISharePointCommandContext context, PublishingPageInfo pageInfo) { Dictionary <string, string> pageProperties = new Dictionary <string, string>(); PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(context.Web); PublishingPage page = publishingWeb.GetPublishingPage(pageInfo.ServerRelativeUrl); if (page != null) { pageProperties = SharePointCommandServices.GetProperties(page); } return(pageProperties); }
public PageLayout Read(SPWeb web) { if (web == null) { return(Read((PublishingWeb)null)); } if (!PublishingWeb.IsPublishingWeb(web)) { throw new ArgumentException("The specified web is not a publishing web."); } PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(web); return(Read(pubWeb)); }
// this method gets all publishing pages for the web private List <string> GetAllPublishingPage() { List <string> pgList = new List <string>(); SPWeb web = SPContext.Current.Web; string fullPageUrl = string.Empty; PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(web); PublishingPageCollection publishingPageCollection = publishingWeb.GetPublishingPages(); List <PageLayout> layouts = new List <PageLayout>(publishingWeb.GetAvailablePageLayouts()); foreach (PageLayout pl in layouts) { pgList.Add(pl.Name); } return(pgList); }
public static void GetNavigation(XmlDocument xmlDoc, SPWeb web, bool includeChildren) { if (PublishingWeb.IsPublishingWeb(web)) { PublishingWeb pubweb = PublishingWeb.GetPublishingWeb(web); XmlElement webNode = (XmlElement)xmlDoc.DocumentElement.AppendChild(xmlDoc.CreateElement("Web")); webNode.SetAttribute("serverRelativeUrl", web.ServerRelativeUrl); GetNavigation(pubweb, webNode); } if (includeChildren) { foreach (SPWeb childWeb in web.Webs) { GetNavigation(xmlDoc, childWeb, true); } } }
private static List <PublishingPageInfo> GetPublishingPages(ISharePointCommandContext context) { List <PublishingPageInfo> pages = new List <PublishingPageInfo>(); PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(context.Web); PublishingPageCollection publishingPages = publishingWeb.GetPublishingPages(); pages = (from PublishingPage page in publishingPages select new PublishingPageInfo { Name = page.Name, ServerRelativeUrl = page.Uri.AbsolutePath, Title = page.Title, }).ToList(); return(pages); }
private PublishingWeb GetPublishingSiteFromWeb(SPWeb web) { PublishingWeb result = null; if (web == null) { throw new ArgumentNullException("web"); } var pubSite = new PublishingSite(web.Site); if (PublishingWeb.IsPublishingWeb(web)) { result = PublishingWeb.GetPublishingWeb(web); } return(result); }
// Uncomment the method below to handle the event raised after a feature has been activated. public override void FeatureActivated(SPFeatureReceiverProperties properties) { SPSite siteCollection = properties.Feature.Parent as SPSite; if (siteCollection != null) { SPWeb topLevelSite = siteCollection.RootWeb; Guid sitePublishingGuid = new Guid("f6924d36-2fa8-4f0b-b16d-06b7250180fa"); Guid webPublishingGuid = new Guid("94c94ca6-b32f-4da9-a9e3-1f3d343d7ecb"); if (siteCollection.Features[sitePublishingGuid] == null) { siteCollection.Features.Add(sitePublishingGuid); } String WebAppRelativePath = topLevelSite.ServerRelativeUrl; if (!WebAppRelativePath.EndsWith("/")) { WebAppRelativePath += "/"; } foreach (SPWeb site in siteCollection.AllWebs) { if (!site.WebTemplate.Contains("APP")) { if (site.Features[webPublishingGuid] == null) { site.Features.Add(webPublishingGuid); } var pubWeb = PublishingWeb.GetPublishingWeb(site); var webNavigationSettings = new Microsoft.SharePoint.Publishing.Navigation.WebNavigationSettings(site); webNavigationSettings.GlobalNavigation.Source = Microsoft.SharePoint.Publishing.Navigation.StandardNavigationSource.PortalProvider; webNavigationSettings.CurrentNavigation.Source = Microsoft.SharePoint.Publishing.Navigation.StandardNavigationSource.PortalProvider; webNavigationSettings.Update(); pubWeb.Update(); site.MasterUrl = WebAppRelativePath + "_catalogs/masterpage/RivernetTeamSite.master"; site.CustomMasterUrl = WebAppRelativePath + "_catalogs/masterpage/RivernetTeamSite.master"; site.SiteLogoUrl = WebAppRelativePath + "_layouts/15/images/RiverStonelogotransparent.png"; site.Update(); } } } }
public override void FeatureActivated(SPFeatureReceiverProperties properties) { SPWeb currentWeb = properties.Feature.Parent as SPWeb; // The Promotions feature should only be activated on a Publishing Site. if (PublishingWeb.IsPublishingWeb(currentWeb)) { PublishingWeb publishingWeb = PublishingWeb.GetPublishingWeb(currentWeb); SPFile defaultPage = publishingWeb.DefaultPage; // If the default page doesn't exist, it needs to be created first. if (defaultPage == null) { defaultPage = CreateNewWelcomePage(currentWeb, publishingWeb, defaultPage); } else { defaultPage.CheckOut(); } try { // Create a custom View that displays only Promotion Pages. SPList pagesList = currentWeb.Lists[PagesList]; SPView promotionsOnlyView = CreatePromotionsOnlyView(currentWeb, pagesList); // Add a list view Web part to display Promotions Only AddListViewWebPartToPage(defaultPage, pagesList, promotionsOnlyView); } finally { defaultPage.CheckIn(CheckInComment); defaultPage.Publish(CheckInComment); } // Save the URL of the site where this feature is being activated. This settings will be used at runtime. SetUrlInConfig(currentWeb); // Register the Promotion RegisterPromotionRepositoryTypeMapping(); } }
public static OutputQueue SetLookoutAsMySiteHomePage(string mySiteWebUrl) { var output = new OutputQueue(); try { using (var site = new SPSite(mySiteWebUrl)) { if (site != null) { using (var web = site.OpenWeb()) { if (web != null) { if (PublishingWeb.IsPublishingWeb(web)) { var publishingWeb = PublishingWeb.GetPublishingWeb(web); var lookoutPageFile = web.GetFile("Lookout.aspx"); publishingWeb.DefaultPage = lookoutPageFile; publishingWeb.Update(); publishingWeb.Close(); } else { var rootFolder = web.RootFolder; rootFolder.WelcomePage = "Lookout.aspx"; rootFolder.Update(); web.Update(); } } } } } } catch (Exception exception) { output.Add(string.Format(CultureInfo.CurrentCulture, Exceptions.ErrorSettingLookoutHomePage, exception.Message), OutputType.Error, string.Empty, exception); } return(output); }
/// <summary> /// Enumerates the specified web. /// </summary> /// <param name="site">The site.</param> /// <param name="web">The web.</param> /// <param name="enumerateSubWebs">if set to <c>true</c> [enumerate sub webs].</param> private void Enumerate(SPSite site, SPWeb web, bool enumerateSubWebs) { OnSPWebEnumerated(site, web); if (SPListEnumerated != null) { for (int i = 0; i < web.Lists.Count; i++) { OnSPListEnumerated(site, web, web.Lists[i]); } } #if MOSS if (PublishingPageEnumerated != null) { if (PublishingWeb.IsPublishingWeb(web)) { PublishingWeb pubWeb = PublishingWeb.GetPublishingWeb(web); foreach (PublishingPage page in pubWeb.GetPublishingPages()) { OnPublishingPageEnumerated(site, web, page); } } } #endif if (enumerateSubWebs) { foreach (SPWeb subWeb in web.Webs) { try { Enumerate(site, subWeb, enumerateSubWebs); } finally { subWeb.Dispose(); } } } }
public void AddPublishingPage() { string pageName = "CustomPage3.aspx"; Web webSite = context.Web; context.Load(webSite); PublishingWeb web = PublishingWeb.GetPublishingWeb(context, webSite); context.Load(web); if (web != null) { List pages = context.Site.RootWeb.Lists.GetByTitle("Pages"); ListItemCollection defaultPages = pages.GetItems(CamlQuery.CreateAllItemsQuery()); context.Load(defaultPages, items => items.Include(item => item.DisplayName).Where(obj => obj.DisplayName == pageName)); context.ExecuteQuery(); if (defaultPages != null && defaultPages.Count > 0) { } else { List publishingLayouts = context.Site.RootWeb.Lists.GetByTitle("Master Page Gallery"); ListItemCollection allItems = publishingLayouts.GetItems(CamlQuery.CreateAllItemsQuery()); context.Load(allItems, items => items.Include(item => item.DisplayName).Where(obj => obj.DisplayName == "PageLayoutTemplate")); context.ExecuteQuery(); ListItem layout = allItems.Where(x => x.DisplayName == "PageLayoutTemplate").FirstOrDefault(); context.Load(layout); PublishingPageInformation publishingPageInfo = new PublishingPageInformation(); publishingPageInfo.Name = pageName; publishingPageInfo.PageLayoutListItem = layout; PublishingPage publishingPage = web.AddPublishingPage(publishingPageInfo); publishingPage.ListItem.File.CheckIn(string.Empty, CheckinType.MajorCheckIn); publishingPage.ListItem.File.Publish(string.Empty); publishingPage.ListItem.File.Approve(string.Empty); context.Load(publishingPage); context.Load(publishingPage.ListItem.File, obj => obj.ServerRelativeUrl); context.ExecuteQuery(); } } }