Subo archivos de la unidad local al sitio de SharePoint usando PowerShell

Tengo una lista de "Documentos", contiene una carpeta llamada "X"

Mi problema es: Cómo subir archivos a X carpeta

Este es mi código:

$SiteURL = "domain/sites/testing/"
$libraryName="Documents/X"
$SPOnlineUserName="user@domain"

El guión funciona bien cuando subo a documentos ($libraryName variable es "Documentos")

Pero cuando $libraryName="Documents/X" carpeta, obtengo este error:

List 'Documents/X' does not exist at site with URL 'domain/sites/testing'

¿Alguna idea de resolver esto?

[Editar]

Puedo acceder a la carpeta "X" a través del navegador.

La mejor

0
Kiven Wanda 1 jul. 2019 a las 11:04

1 respuesta

La mejor respuesta

Actualización para la carga de archivos grandes:

Add-Type -Path "C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\16\ISAPI\Microsoft.SharePoint.Client.dll"
Add-Type -Path "C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\16\ISAPI\Microsoft.SharePoint.Client.Runtime.dll"

$SiteURL="https://tenant.sharepoint.com/sites/dev"
$User = "user@tenant.onmicrosoft.com"  
$Password = '*********************' 
$Credentials = New-Object Microsoft.SharePoint.Client.SharePointOnlineCredentials($User,(ConvertTo-SecureString $Password -AsPlainText -Force))
$ctx = New-Object Microsoft.SharePoint.Client.ClientContext($SiteURL)
$ctx.Credentials = $Credentials

$fileChunkSizeInMB = 9

# Each sliced upload requires a unique ID.
$UploadId = [GUID]::NewGuid()

# Get the name of the file.
$UniqueFileName = [System.IO.Path]::GetFileName("D:\\Yoyo.wmv")


# Get the folder to upload into. 
$Docs = $ctx.Web.Lists.GetByTitle("Documents")
$ctx.Load($Docs)
$ctx.Load($Docs.RootFolder)
$ctx.ExecuteQuery()

# Get the information about the folder that will hold the file.
$ServerRelativeUrlOfRootFolder = $Docs.RootFolder.ServerRelativeUrl

# File object.
[Microsoft.SharePoint.Client.File] $upload


# Calculate block size in bytes.
$BlockSize = $fileChunkSizeInMB * 1024 * 1024


# Get the size of the file.
$FileSize = (Get-Item $fileName).length

if ($FileSize -le $BlockSize)
{
    # Use regular approach.
    $FileStream = New-Object IO.FileStream($fileName,[System.IO.FileMode]::Open)
    $FileCreationInfo = New-Object Microsoft.SharePoint.Client.FileCreationInformation
    $FileCreationInfo.Overwrite = $true
    $FileCreationInfo.ContentStream = $FileStream
    $FileCreationInfo.URL = $UniqueFileName
    $Upload = $Docs.RootFolder.Files.Add($FileCreationInfo)
    $ctx.Load($Upload)
    $ctx.ExecuteQuery()
    return $Upload
}
else
{

    # Use large file upload approach.
    $BytesUploaded = $null

    $Fs = $null

    Try {

        $Fs = [System.IO.File]::Open($fileName, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::ReadWrite)

        $br = New-Object System.IO.BinaryReader($Fs)

        $buffer = New-Object System.Byte[]($BlockSize)
        $lastBuffer = $null
        $fileoffset = 0
        $totalBytesRead = 0
        $bytesRead
        $first = $true
        $last = $false

        # Read data from file system in blocks. 
        while(($bytesRead = $br.Read($buffer, 0, $buffer.Length)) -gt 0) {

            $totalBytesRead = $totalBytesRead + $bytesRead

            # You've reached the end of the file.
            if($totalBytesRead -eq $FileSize) {
                $last = $true
                # Copy to a new buffer that has the correct size.
                $lastBuffer = New-Object System.Byte[]($bytesRead)
                [array]::Copy($buffer, 0, $lastBuffer, 0, $bytesRead)
            }

            If($first)
            {
                $ContentStream = New-Object System.IO.MemoryStream

                # Add an empty file.
                $fileInfo = New-Object Microsoft.SharePoint.Client.FileCreationInformation
                $fileInfo.ContentStream = $ContentStream
                $fileInfo.Url = $UniqueFileName
                $fileInfo.Overwrite = $true
                $Upload = $Docs.RootFolder.Files.Add($fileInfo)
                $ctx.Load($Upload)

                # Start upload by uploading the first slice.

                $s = [System.IO.MemoryStream]::new($buffer) 

                # Call the start upload method on the first slice.
                $BytesUploaded = $Upload.StartUpload($UploadId, $s)
                $ctx.ExecuteQuery()

                # fileoffset is the pointer where the next slice will be added.
                $fileoffset = $BytesUploaded.Value

                # You can only start the upload once.
                $first = $false

            }
            Else
            {
                # Get a reference to your file.
                $Upload = $ctx.Web.GetFileByServerRelativeUrl($Docs.RootFolder.ServerRelativeUrl + [System.IO.Path]::AltDirectorySeparatorChar + $UniqueFileName);

                If($last) {

                    # Is this the last slice of data?
                    $s = [System.IO.MemoryStream]::new($lastBuffer)


                    # End sliced upload by calling FinishUpload.
                    $Upload = $Upload.FinishUpload($UploadId, $fileoffset, $s)
                    $ctx.ExecuteQuery()


                    Write-Host "File upload complete"
                    # Return the file object for the uploaded file.
                    return $Upload

                }
                else {

                    $s = [System.IO.MemoryStream]::new($buffer)

                    # Continue sliced upload.
                    $BytesUploaded = $Upload.ContinueUpload($UploadId, $fileoffset, $s)
                    $ctx.ExecuteQuery()

                    # Update fileoffset for the next slice.
                    $fileoffset = $BytesUploaded.Value

                }
            }

        }
    }
    Catch 
    {
        Write-Host $_.Exception.Message -ForegroundColor Red
    }
    Finally 
    {

        if ($Fs -ne $null)
        {
            $Fs.Dispose()
        }

    }
}
2
Jerry 3 jul. 2019 a las 09:43