Keep It Simple

Esta semana tive de resolver um problema bem interessante em um projeto que estamos desenvolvendo, era necesário que o
SharePoint a partir de informações de um sistema legado cria-se uma série de subsites, por uma série de motivos que não vale a
pena comentar aqui, não foi criado um site definition o que seria o mais recomendável e como o site de modelo usava os recusros de
publicação não era possivel gerar um template.
Neste momento surge um engraçadinho e diz que é possível se gerar o modelo acessando diretamente a página em _layouts/savetmpl.aspx,
isso é parcialmente verdade primeiro porque é uma ação não suportada e segundo porque o modelo gerado nem sempre funciona.
E agora o que fazer? Supreendentemente a abordagem foi bem simples apelamos para o stsadm e exportamos o site gerando um arquivo
*.cmp, o comando é bem simples vejamos

C:\Windows\system32>stsadm -o export

Missing required argument: url.
Missing required argument: filename.

stsadm.exe -o export
           -url <URL to be exported>
           -filename <export file name>
               [-overwrite]
           [-includeusersecurity]
           [-haltonwarning]
           [-haltonfatalerror]
           [-nologfile]
           [-versions <1-4>
               1 - Last major version for files and list items (default)
               2 - The current version, either the last major or the last minor
               3 - Last major and last minor version for files and list items
               4 - All versions for files and list items]
           [-cabsize <integer from 1-1024 megabytes> (default: 24)]
           [-nofilecompression]
           [-quiet]
           [-usesqlsnapshot]

Os dois parametros principais são a url do site e o nome do arquivo, os demais indicam como deve ser tratado o versionamento, segurança
e compressão, nada muito complicado, similarmente o processo de importação é parecido

C:\Windows\system32>stsadm -o import

Missing required argument: url.
Missing required argument: filename.

stsadm.exe -o import
           -url <URL to import to>
           -filename <import file name>
           [-includeusersecurity]
           [-haltonwarning]
           [-haltonfatalerror]
           [-activatesolutions]
           [-nologfile]
           [-updateversions <1-3>
               1 - Add new versions to the current file (default)
               2 - Overwrite the file and all its versions (delete then insert)
               3 - Ignore the file if it exists on the destination]
           [-includeusercustomaction <1-2>
               1 - Ignore user custom actions
               2 - Include user custom actions (default)]
           [-nofilecompression]
           [-quiet]

Legal, via stsadm é possível exportar e importar um site ou conteúdo de um SharePoint para outro, mas como isso me ajuda? Bem, o
processo de importação não obriga que a url de destina seja a mesma de origem permitindo que eu’faça um reparenting do site, assim
au posso ter um Site A que é exportado e posteriormente importado como Site B e até mesmo em uma  estrutura diferente da original.
Fantástico neste ponto estamos a meio caminho andado de resolver o problema, resta agora uma forma de executar esses comandos via
object model, apesar de não ser tão simples quanto o stsadm, também não é nada muito complicado, vejamos:

        Private m_webName = String.Empty
        Privatem_webParentUrl = String.Empty

        Public Overloads Overrides SubFeatureActivated(ByVal properties AsSPFeatureReceiverProperties)

            DimstrSiteUrl As String= String.Empty

            strSiteUrl = "http://vm-dev/novosite"

           Dimsettings As NewSPImportSettings()
            Withsettings
                .SiteUrl = strSiteUrl
                .FileLocation = SPUtility.GetGenericSetupPath("TEMPLATE\FEATURES\SiteCreator\model")
                .FileCompression = True
                .UpdateVersions = SPUpdateVersions.Overwrite
                .IncludeSecurity = SPIncludeSecurity.All
                .UserInfoDateTime = SPImportUserInfoDateTimeOption.ImportAll
                .BaseFileName = "modelo.cmp"
           End With

            Usingsite AsSPSite = NewSPSite(settings.SiteUrl)
                Me.m_webParentUrl = site.ServerRelativeUrl
                Me.m_webName = ConvertToServiceRelUrl(Me.GetServerRelUrlFromFullUrl(settings.SiteUrl), site.ServerRelativeUrl)
            End Using

            Dimimport As NewSPImport(settings)
            Dimhandler AsEventHandler(OfSPDeploymentEventArgs) = NewEventHandler(OfSPDeploymentEventArgs)(AddressOf Me.OnStarted)
            AddHandler import.Started, handler

            import.Run()
            Usingsite AsSPSite = NewSPSite(settings.SiteUrl)
                UsingoWeb AsSPWeb = site.OpenWeb(Me.GetServerRelUrlFromFullUrl(settings.SiteUrl)) oWeb.MasterUrl = "/_catalogs/masterpage/default_modelo.master"
                   oWeb.CustomMasterUrl = "/_catalogs/masterpage/default_modelo.master"
                   oWeb.Title = "Novo Site"
                   oWeb.Update()

                    DimpubWeb AsPublishingWeb = PublishingWeb.GetPublishingWeb(oWeb)
                    DimWelcomePage As String= SPHttpUtility.UrlPathDecode("paginas/default.aspx", True)
                    DimPageFile AsSPFile = pubWeb.Web.GetFile(WelcomePage)
                    pubWeb.DefaultPage = PageFile
                    pubWeb.Update()

                End Using
            End Using
        End Sub

        Private Sub OnStarted(ByVal sender As Object, ByVal args As SPDeploymentEventArgs)
            Dim rootObjects As SPImportObjectCollection = args.RootObjects
            If (rootObjects.Count <> 0) Then
                If (rootObjects.Count = 1) Then
                    If (rootObjects.Item(0).Type = SPDeploymentObjectType.Web) Then
                        rootObjects.Item(0).TargetParentUrl = Me.m_webParentUrl
                        rootObjects.Item(0).TargetName = Me.m_webName
                    ElseIf Not Me.m_webParentUrl.EndsWith("/", StringComparison.OrdinalIgnoreCase) Then
                        rootObjects.Item(0).TargetParentUrl = (Me.m_webParentUrl & "/" & Me.m_webName)
                    Else
                        rootObjects.Item(0).TargetParentUrl = (Me.m_webParentUrl & Me.m_webName)
                    End If
                Else
                    Dim flag As Boolean = False
                    Dim i As Integer
                    For i = 0 To rootObjects.Count - 1
                        rootObjects.Item(i).TargetParentUrl = Me.m_webParentUrl
                        If (rootObjects.Item(i).Type = SPDeploymentObjectType.Web) Then
                            If flag Then
                                Throw New SPException(SPResource.GetString("ImportOperationMultipleRoots", New 

Object(0 - 1) {}))
                            End If
                            flag = True
                            rootObjects.Item(i).TargetName = Me.m_webName
                            Return
                        End If
                    Next i
                End If
            End If
        End Sub

Neste exemplo eu usei o evento featureactivated para criar um site com base no cmp, o códigoé bastante auto explicativo mas vamos a
alguns detalhes

            strSiteUrl = "http://vm-bovespadev/novosite"

            Dim settings As New SPImportSettings()
            With settings
                .SiteUrl = strSiteUrl
                .FileLocation = SPUtility.GetGenericSetupPath("TEMPLATE\FEATURES\SiteCreator\model")
                .FileCompression = True
                .UpdateVersions = SPUpdateVersions.Overwrite
                .IncludeSecurity = SPIncludeSecurity.All
                .UserInfoDateTime = SPImportUserInfoDateTimeOption.ImportAll
                .BaseFileName = "modelo.cmp"
            End With

Este trecho cria um objeto SPImportSettings que formece instruções ao importador de como tratar o arquivo de forma muito similar aos
parâmetros do stsadm e novamente os mais importantes são a url do site e o path do arquivo, assim na variável strSiteUrl definimos a url
de destino e através do método utilitário SPUttility.GetGenericSetupPath definimos o local onde se encontra o cmp, no caso na pasta da
feature la na hive 12,  como neste caso é uma feature poderia ter usado a propriedade properties.Feature.Definition.RootDirectory, optei
pelo sputility porque a versão final seria executada em um timerjob onde não teria acesso a esta propriedade.

Dim import As New SPImport(settings)
Dim handler As EventHandler(Of SPDeploymentEventArgs) = New EventHandler(Of SPDeploymentEventArgs)(AddressOf 

Me.OnStarted)
AddHandler import.Started, handler

import.Run()

Neste trecho temos o segredo para o reparenting, passamos o settings para o importador e registramos um evento handler no evento OnStarded do importador, este evento será disparado para cada item e nele poderemos definir quem é o item pai como vemos abaixo

        Private Sub OnStarted(ByVal sender As Object, ByVal args As SPDeploymentEventArgs)
            Dim rootObjects As SPImportObjectCollection = args.RootObjects
            If (rootObjects.Count <> 0) Then
                If (rootObjects.Count = 1) Then
                    If (rootObjects.Item(0).Type = SPDeploymentObjectType.Web) Then
                        rootObjects.Item(0).TargetParentUrl = Me.m_webParentUrl
                        rootObjects.Item(0).TargetName = Me.m_webName
                    ElseIf Not Me.m_webParentUrl.EndsWith("/", StringComparison.OrdinalIgnoreCase) Then
                        rootObjects.Item(0).TargetParentUrl = (Me.m_webParentUrl & "/" & Me.m_webName)
                    Else
                        rootObjects.Item(0).TargetParentUrl = (Me.m_webParentUrl & Me.m_webName)
                    End If
                Else
                    Dim flag As Boolean = False
                    Dim i As Integer
                    For i = 0 To rootObjects.Count - 1
                        rootObjects.Item(i).TargetParentUrl = Me.m_webParentUrl
                        If (rootObjects.Item(i).Type = SPDeploymentObjectType.Web) Then
                            If flag Then
                                Throw New SPException(SPResource.GetString("ImportOperationMultipleRoots", 

New Object(0 - 1) {}))
                            End If
                            flag = True
                            rootObjects.Item(i).TargetName = Me.m_webName
                            Return
                        End If
                    Next i
                End If
            End If
        End Sub

A cada chamada o evento recebe uma coleção rootobjects indicando o que esta sendo importado, se o evento receber 1 item e este for do tipo
web ele é o novo site, sendo assim seu pai será o site pai de NovoSite indicado na url no caso http://vm-dev, por outro lado se a coleção tiver
mais de um item seu site pai será o próprio NovoSite.
O resto do código define uma nova master para o site, troca o título e define uma nova welcome page.
Voltando a nosso problema original, este código foi colocado em um timerjob que diariamente acessa um sistema legado e identifica os novos
resgistros e cria automaticamente um novo site para cada novo item.
Bem amigos foi um post longo, mas espero que possa ser útil para vocês

Até mais.