Lancement d'un powershell via tâche planifiée

Il arrive en production de devoir lancer des scripts certains jours ou à une certaine heure de la journée.

Les tâches planifiées Windows peuvent vous aider à effectuer ce travail.


Depuis l'outil "Task Sheduler" effectuez un clic droit puis "Create new task"

Spécifiez un nom pour la tâche puis un mode de lancement

Puis un type de schedule ici une fois par mois le dernier jour du mois à 23h30

Ajouter une action

Saisir "Powershell.exe" dans le programme à lancer. Saisir dans les arguments "-File" puis le chemin complet vers le fichier.

Enregistrer enfin la tâche et tester là via l'option "Run"

Suppression de documents en masse dans SharePoint à l'aide de SPWeb.ProcessBatchData

Aujourd'hui je dois supprimer plus de 100.000 documents dans plusieurs collection de sites et le tout en un temps de traitement le plus court qui soit, VDM.

Cela aurait pu se terminer comme ça !

Plus sérieusement, SharePoint offre plusieurs moyen pour supprimer des éléments au sein d'une liste / Bibliothèque. En revanche toutes les méthodes ne sont pas aussi performantes, en particulier la fonction SPList.Items.DeleteById si cette fonction reste facile à utiliser et à mettre en place lors de la suppression d'un ou plusieurs éléments.

Mais lorsqu'il s'agit de supprimer plusieurs milliers d'élément cela va lentement très très lentement (environ 3-4 secondes par fichier sur un environnement de développement) Alors effectuer ce traitement sur un volume plus important va vite devenir problématique.

Heureusement une autre fonction existe et permet d'effectuer des traitements par lot.  La méthode SPWeb.ProcessBatchData prend en paramètre une chaîne CAML (Collaborative Application Markup Language) qui contient les commandes, qui se compose d'un élément de Batch et un nombre quelconque d'éléments subordonnés Method qui spécifient chacun une méthode d'appel (RPC) de procédure à distance SharePoint .

 La forme la plus simple est la suivante:
<batch>
  <method>
    <setlist scope="Request">ID_LIST</setlist>
    <setvar name="ID">ID_ELEMENT</setvar>
    <setvar md="" name="`">COMMANDE</setvar>
  </method>
</batch>

Dans le cadre d'une suppression en masse la fonction suivante qui prend en paramètre l'url du site et le nom de la bibliothèque permet de supprimer les éléments par lot de 2000.
Une requête CAML permet de faire un filtre sur les documents à supprimer.

Function purgeSite($params){

$web = get-spweb $params[0]
$list = $web.lists[$params[1]]

    try
    {
        $i=0
        $spQuery = New-Object Microsoft.SharePoint.SPQuery
        $spQuery.ViewFieldsOnly = $true
        $spQuery.Query = "<where><lt><fieldref name="Created"><value type="DateTime"><today offsetdays="2"></today></value></fieldref></lt></where>"
        $spQuery.RowLimit = 2000;
        $itemCount = 0;          
        $listId = $list.ID;

        do
        {
            [System.Text.StringBuilder]$batchXml = New-Object "System.Text.StringBuilder";
            $batchXml.Append("<batch>");
            $command = [System.String]::Format( "<method><setlist scope="Request">{0}</setlist><setvar name="`">{1}</setvar><setvar name="owsfileref">{2}</setvar><setvar md="" name="`">Delete</setvar></method>", $listId, "{0}","{1}" );

            $listItems = $list.GetItems($spQuery)
            $spQuery.ListItemCollectionPosition = $listItems.ListItemCollectionPosition
            $count = $listItems.Count

            Write-Host $count
            foreach ($item in $listItems)
            {
                Write-Host -ForegroundColor Green "Delete item "$item.ID
                $list.Items.DeleteItemById($item.ID)
                if($item -ne $null)
                {
                    $batchXml.Append([System.String]::Format($command, $item.ID.ToString(),$item["FileRef"])) | Out-Null;
                }
                #break;
            }
            $batchXml.Append("</batch>");

          #  $web.ProcessBatchData($batchXml.ToString())

            $result = $web.ProcessBatchData($batchXml.ToString())
       
            $web.RecycleBin.DeleteAll()

        }
        while ($spQuery.ListItemCollectionPosition -ne $null)
    }
    catch
    {
        Write-Host -ForegroundColor Red $_.Exception.ToString()
    }
}

Powershell : Reporting Service, modification de l'email d'abonnement

L'exemple de script PowerShell suivant met à jour la configuration de l'extension de remise du courrier électronique par le serveur de rapports pour l'application de service nommée My RS Service App. Mettez à jour les valeurs du serveur SMTP

#Modification de l'email Service reporting
$app=get-sprsserviceapplication -Name $rsService
$emailCfg = Get-SPRSExtension -identity $app -ExtensionType "Delivery" -name "Report Server Email" | select -ExpandProperty ConfigurationXml
$emailXml = [xml]$emailCfg
$emailXml.SelectSingleNode("//SMTPServer").InnerText = $smptServer
$emailXml.SelectSingleNode("//SendUsing").InnerText = "2"
$emailXml.SelectSingleNode("//SMTPAuthenticate").InnerText = "2"
$emailXml.SelectSingleNode("//From").InnerText = $fromAddr
Set-SPRSExtension -identity $app -ExtensionType "Delivery" -name "Report Server Email" -ExtensionConfiguration $emailXml.OuterXml

SharePoint 2013 Managed Meta data .csv and Setting site navigation to use taxonomy using PowerShell and Custom Property

You can import .csv file using the following powershell function, you can after launch the function with the following parameters:

webApplication URL
CSV file path
Group Term Name

In order to set the managed metadata Navigation you have to set the option in "Navigation" menu.

Param(
 [Parameter(Mandatory=$True,Position=1)]
 [string]$WebAppUrl,
 [Parameter(Mandatory=$True,Position=2)]
 [string]$CSVFilePath,
 [Parameter(Mandatory=$True,Position=3)]
 [string]$TermGroupName
)

Add-PSSnapin Microsoft.SharePoint.PowerShell -erroraction SilentlyContinue

function ImportTermSet([Microsoft.SharePoint.Taxonomy.TermStore]$store, [string]$groupName, [PSCustomObject]$termSet) { 
   function ImportTerm([Microsoft.SharePoint.Taxonomy.Group]$group,
                       [Microsoft.SharePoint.Taxonomy.TermSet]$set,
                       [Microsoft.SharePoint.Taxonomy.Term]$parent,
                       [string[]]$path) {       
     if ($path.Length -eq 0) {
       return
     }
      elseif ($group -eq $null)
       {
       $group = $store.Groups | where { $_.Name -eq $path[0] }
       if ($group -eq $null)
       {
         $group = $store.CreateGroup($path[0])
       }
      }
      elseif ($set -eq $null)
       {
       $set = $group.TermSets | where { $_.Name -eq $path[0] }
       if ($set -eq $null)
        {
         $set = $group.CreateTermSet($path[0])
        }
        $set.SetCustomProperty("_Sys_Nav_IsNavigationTermSet", "True")
     }
      else
       {
       $node = if ($parent -eq $null) { $set } else { $parent }
       $parent = $node.Terms | where { $_.Name -eq $path[0] }      
       if ($parent -eq $null -and $path -ne $null -and $path[0] -ne $null) {
         $parent = $node.CreateTerm($path[0], 1036)
        #Debut Menu
        if($_.MenuID -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Menu ID", $_.MenuID)
        }
        if($_.Menu_Particulier -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Menu Particulier", $_.Menu_Particulier)
        }
        if($_.Menu_Professionnel -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Menu Professionnel", $_.Menu_Professionnel)
        }
        if($_.SousTitre -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Sous Titre", $_.SousTitre)
        }
        if($_.TitreAccueil -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Titre accueil", $_.TitreAccueil)
        }
        if($_.SousTitreAccueil -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Sous titre accueil", $_.SousTitreAccueil)
        }
        if($_.Picto -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Picto", $_.Picto)
        }
        #Fin Menu
        #Debut colonne
        if($_.ColonneID -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Colonne ID", $_.ColonneID)
        }
        if($_.ClasseTitreColonne -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Classe titre colonne", $_.ClasseTitreColonne)
        }
        if($_.TitreColonne -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Titre colonne", $_.TitreColonne)
        }
        #Fin colonne
        #Debut lien
        if($_.LienID -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Lien ID", $_.LienID)
        }
        if($_.SousTitreLien -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Sous titre lien", $_.SousTitreLien)
        }
        #Fin lien
        #Debut rubrique
        if($_.RubriqueID -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Rubrique ID", $_.RubriqueID)
        }
        if($_.BaliseRubriqueIcon -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Balise rubrique icone", $_.BaliseRubriqueIcon)
        }
        if($_.ClasseIconRubrique -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Classe icone rubrique", $_.ClasseIconRubrique)
        }
        if($_.TitreIcon -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Titre icone", $_.TitreIcon)
        }
        if($_.SousTitreIcon -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Sous titre icone", $_.SousTitreIcon)
        }
        if($_.ClasseLien -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Classe lien", $_.ClasseLien)
        }
        if($_.TitreLien -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Titre lien", $_.TitreLien)
        }
        if($_.EmphaseTitre -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Emphase titre", $_.EmphaseTitre)
        }
        if($_.ParentRubriqueID -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Parent rubrique ID", $_.ParentRubriqueID)
        }
        if($_.ClasseSousTitre -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Classe sous titre", $_.ClasseSousTitre)
        }
        if($_.ClasseParagrapheEnglobantLien -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Classe paragraphe englobant lien", $_.ClasseParagrapheEnglobantLien)
        }
        #Fin rubrique
        if($_.Ordre -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Ordre", $_.Ordre)
        }
        if($_.ClasseCSS -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Classe CSS", $_.ClasseCSS)
        }
        if($_.Visible -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Visible", $_.Visible)
        }
        if($_.Type -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("Type", $_.Type)
        }
        if($_.PlanSite -ne "" -and $parent  -ne $null )
        {
            $parent.SetLocalCustomProperty("PlanSite", $_.PlanSite)
        }
       }
     }

     ImportTerm $group $set $parent $path[1..($path.Length)]
         Commit $store 2>&1 | out-null
   }

   function RemoveTermGroup([Microsoft.SharePoint.Taxonomy.TermStore]$store, [string]$groupName) {
     $group = $store.Groups | where { $_.Name -eq $groupName }
     if ($group -ne $null) {
       $group.TermSets | foreach { $_.Delete() }
       $group.Delete()
       $store.CommitAll()
     }
   }
   function Commit($store) {
     $store.CommitAll()
   }

   $termSetName = $termSet[0]."Term Set Name"
   $termSet | where { $_."Level 1 Term" -ne "" } | foreach {
     $path = @($groupName, $termSetName) + @(for ($i = 1; $i -le 5; $i++) {
       $term = $_."Level $i Term"
         if ($term -eq "") {
           break
         } else {
           $term
         }
       }
     )
     ImportTerm -path $path
     $ErrorActionPreference = "Continue";
   }
   }

$session = [Microsoft.SharePoint.Publishing.Navigation.TaxonomyNavigation]::CreateTaxonomySessionForEdit($web)
$store = $session.TermStores[0]
$termSet = Import-csv $CSVFilePath
ImportTermSet $store $TermGroupName $termSet

$store.CommitAll()

Change SPWeb Properties, CreateFriendlyUrlsForNewPages and CreateFriendlyUrlsForNewPages for SharePoint 2013 Navigation

Use the following Powershell in order to change the behavior of the managed navigation when you create a new page. Replace whether by true or false in order to fit the needs.


Add-PSSnapin Microsoft.SharePoint.PowerShell -erroraction SilentlyContinue
$site = Get-SPSite $siteUrl;

$site.AllWebs | foreach {

$webNav = $_.Properties["_webnavigationsettings"];
$webNav ;

#Replace  AddNewPagesToNavigation="True"  and  CreateFriendlyUrlsForNewPages="True" 


$webNav = $webNav.Replace('AddNewPagesToNavigation="True"','AddNewPagesToNavigation="False"');
$webNav = $webNav.Replace('CreateFriendlyUrlsForNewPages="True"','CreateFriendlyUrlsForNewPages="False"');
$_.Properties["_webnavigationsettings"] = $webNav;
$_.Properties.Update();
$_.Update();
}

Modify Site Collection URL SharePoint 2010

In order to rename a Site collection in SharePoint 2010 you need to backup the site first and restore it on an new Site collection. To do that you can use the following PowerShell : Add-PSSnapin Microsoft.SharePoint.PowerShell -ErrorAction SilentlyContinue     #Get the Source Site Collection URL $sourceURL = Read-Host “Enter the Source Site Collection URL:”    #Get the Target Site Collection URL $targetURL = Read-Host “Enter the Destination Site Collection URL”    #Location for the backup file  $backupPath = Read-Host “Enter the Backup File name & location (E.g. c:\temp\Source.bak):”    #Backup the source site collection Backup-SPSite $sourceURL -Path $backupPath -force    #Delete source Site Collection  Remove-SPSite -Identity $sourceURL -Confirm:$false    #Restore Site Collection to new URL Restore-SPSite $targetURL -Path $backupPath -Confirm:$false    #Remove backup files Remove-Item $backupPath    write-host "Process Completed!"