Como regenerar a aparência composta quando um CSS temático evolui?

Question

Em um site de publicação corporativa, estamos usando aparências compostas para permitir que os gerentes do site escolham um esquema de cores de marca.

Basicamente, marcamos o portal usando dois arquivos CSS.A main.css arquivo que contém a maioria das regras e que está localizado no Style library.E outro theme.css que contém todas as regras que dependem do tema.

Assim, os usuários podem escolher seu esquema de cores usando o menu “Alterar aparência” nas configurações do site.

Isso está funcionando muito bem (algumas dicas relacionadas à página mestra do sistema, mas isso está fora do escopo).

No entanto, temos algumas alterações nos implementos no theme.css arquivo.Devido ao mecanismo de aparência composta, as alterações neste arquivo não serão refletidas até que o tema seja aplicado novamente.

Como há muitas áreas no portal, está fora de questão regenerar manualmente o tema em todos os subsites.

Existe alguma forma de forçar a regeneração do tema?

Se necessário, um script PowerShell pode ser usado.Eu tentei:

function ReapplyTheme{
    param(
        [Microsoft.SharePoint.SPWeb]$Web
    )

    $file=$web.GetFile($web.ServerRelativeUrl.TrimEnd('/') + "/_catalogs/theme/15/Palette_rouge.spcolor")
    $theme=[Microsoft.SharePoint.Utilities.SPTheme]::Open("Name of my theme", $file)
    $theme.ApplyTo($web, $false)

}

Mas esse script quebra o subsite.Além disso, a paleta de cores e o nome do tema são codificados...Talvez haja algum lugar para cuidar dos valores?

Answer 1

Vejo que você conseguiu resolver o problema usando o script do PowerShell e verificando se um tema foi aplicado, etc.

Apenas para sua informação, na classe SPTheme você pode encontrar alguns métodos estáticos:

• Para obter o tema atual, você pode usar o método estático OpenAppliedTheme
• Para regenerar os estilos temáticos você pode usar o método estático EnforceThemedStylesForWeb
• Ou você pode simplesmente reaplicar o tema atual usando o método ApplyTo

É claro que você também pode usar esses métodos em seu script do PowerShell.

public static void ReapplyCurrentComposedLook(SPWeb web)
{
  // try to get the currently applied theme
  SPTheme theme = SPTheme.OpenAppliedTheme(web);
  if (theme == null)
  {
    // return if no theme is applied
    return;
  }

  // reinforce the styles for the web..
  SPTheme.EnforceThemedStylesForWeb(web);

  // .. or simply reapply the whole theme.
  theme.ApplyTo(web, true);
}

Answer 2

Finalmente fiz meu roteiro evoluir.

Basicamente, em cada subweb cuido do look composto com ordem “0”, que é o tema atual.Também verifico as propriedades do objeto da web para verificar se a web está configurada para herdar seu pai ou não.

Usando os dados da aparência composta encontrada, posso regenerá-los.

Parece funcionar muito bem.

Aqui está o roteiro:

#requires -PSSnapin Microsoft.SharePoint.PowerShell

param(
    [Parameter(Mandatory = $true, Position=0, ParameterSetName='SPSite')]
    [Microsoft.SharePoint.PowerShell.SPSitePipeBind]$Site,
    [Parameter(Mandatory = $true, Position=0, ParameterSetName='SPWeb')]
    [Microsoft.SharePoint.PowerShell.SPWebPipeBind]$Web,
    [Parameter(Position=1)]
    [Switch]$Recurse=$true
    #TODO: add argument to allow specify a specific theme, instead of regenerating it
)

$actualWeb = if(-Not $Web) {
    $site.Read().RootWeb
} else{
    $Web.Read()
}


function Get-ThemeData{
    param(
        [Parameter(Mandatory=$true)]
        [Microsoft.SharePoint.SPWeb]$Web
    )


    $designList = $Web.GetList($web.ServerRelativeUrl.TrimEnd('/') + "/_catalogs/design")
    $query = New-Object Microsoft.SharePoint.SPQuery
    $query.ViewFieldsOnly = $true
    $query.ViewFields = "<FieldRef Name='ThemeUrl' /><FieldRef Name='ImageUrl' /><FieldRef Name='FontSchemeUrl' />"
    $query.Query = "<Where><Eq><FieldRef Name='DisplayOrder' /><Value Type='Number'>0</Value></Eq></Where>";

    $designItem = $designList.GetItems($query)[0]

    $resultProperties = @{
        "Web" = $Web.ServerRelativeUrl
        "FontSchemeUrl" = $designItem["FontSchemeUrl"]
        "ThemeUrl" = $designItem["ThemeUrl"]
        "ImageUrl" = $designItem["ImageUrl"]
        "InheritsThemedCssFolderUrl" = [bool]::Parse($web.AllProperties["__InheritsThemedCssFolderUrl"])
        "InheritsCustomMasterUrl" = [bool]::Parse($web.AllProperties["__InheritsCustomMasterUrl"])
        "InheritsMasterUrl" = [bool]::Parse($web.AllProperties["__InheritsMasterUrl"])
        MasterUrl=$web.MasterUrl
        CustomMasterUrl=$web.CustomMasterUrl
    }

    New-Object PSObject -Property $resultProperties 
}

function Process-SPWeb{
    param(
        [Parameter(Mandatory=$true)]
        [Microsoft.SharePoint.SPWeb]$Web
    )
    Write-Host "Traitement de $($web.ServerRelativeUrl)"

    $themeData = Get-ThemeData $Web

    if(-not $themeData.InheritsThemedCssFolderUrl){
        $color = if($themeData.ThemeUrl) { $web.GetServerRelativeUrlFromUrl((New-Object Microsoft.SharePoint.SPFieldUrlValue($themeData.ThemeUrl)).Url) }
        $font = if($themeData.FontSchemeUrl) { $web.GetServerRelativeUrlFromUrl((New-Object Microsoft.SharePoint.SPFieldUrlValue($themeData.FontSchemeUrl)).Url) }
        $image = if($themeData.ImageUrl) { $web.GetServerRelativeUrlFromUrl((New-Object Microsoft.SharePoint.SPFieldUrlValue($themeData.ImageUrl)).Url) }


        $web.ApplyTheme($color,$font,$image, $false)
        $web2 = Get-SPWeb $web.url
        $web2.MasterUrl = $themeData.MasterUrl
        $web2.CustomMasterUrl = $themeData.CustomMasterUrl
        $web2.Update()
        $web2.Dispose()

        Write-Warning "Thème regénéré sur $($web.ServerRelativeUrl)"
    }

    if($Recurse){
        $Web.Webs | % { Process-SPWeb $_ }

    }

}


Process-SPWeb $actualWeb