Posts tagged trick SharePoint 2013 Hosting

SharePoint 2013 Hosting – HostForLIFE.eu :: Easy Debugging With Developer Dashboard In SharePoint

Sep 24th

Posted by Peter in European SharePoint 2013 Hosting

As we know writing code for SharePoint sites is not difficult whether we are writing server side or client-side code for customizing features. The main point where everyone gets struck is troubleshooting or handling errors related to code. Also, error logging for SharePoint sites is done to both ULS and Windows Event Logs and finding or reading logs sometimes is really a mess. As, reading ULS (SharePoint Unified Logging Service) is not easy for everyone to get through. So, a new feature was introduced in SharePoint 2010 named Developer Dashboard.

What is developer dashboard?

Developer Dashboard is introduced as a new feature in SharePoint 2010. It’s a user interface which reflects useful diagnostic information. Developer dashboards are helpful to not only developers in debugging but also to administrators in handling issues related to farm.

Developer Dashboard gives the information about performance of controls used of a SharePoint page. Also, it tells about execution time taken by each control, log correlation ID, critical events, database queries with their handling time, service calls, SPRequests allocation whether used nominal or not and webparts event offsets (time taken in loading and rendering of webparts). This is a very helpful performance tuning feature. By default, this feature is disabled. We may enable it by:

Powershell script
STSADM command
using code

Enable developer dashboard SharePoint 2016/2013 using PowerShell script

We may easily enable or disable developer dashboard in SharePoint using PowerShell script as below,

Enable Developer Dashboard SharePoint

$var = Microsoft.SharePoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings;  
$var.DisplayLevel = [Microsoft.SharePoint.Administration.SPDeveloperDashboardLevel]::On  
$var.Update()

$var = Microsoft.SharePoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings;

$var.DisplayLevel = [Microsoft.SharePoint.Administration.SPDeveloperDashboardLevel]::On

$var.Update()

Enable on Demand

$var.DisplayLevel = ‘OnDemand’;

1	$var.DisplayLevel = ‘OnDemand’;

Display level for Developer dashboard can also be set as ‘OnDemand’.

Disable Developer Dashboard SharePoint

$var = Microsoft.SharePoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings;  
$var.DisplayLevel = [Microsoft.SharePoint.Administration.SPDeveloperDashboardLevel]::Off  
$var.Update()

$var = Microsoft.SharePoint.Administration.SPWebService]::ContentService.DeveloperDashboardSettings;

$var.DisplayLevel = [Microsoft.SharePoint.Administration.SPDeveloperDashboardLevel]::Off

$var.Update()

Just and On/Off and it can be enabled or disabled.

Enable developer dashboard SharePoint 2010 STSADM

Below is the STSADM command to enable or disable developer dashboard in SharePoint.

Enable Developer Dashboard SharePoint

stsadm -o setproperty -pn developer-dashboard -pv on

Disable Developer Dashboard

stsadm -o setproperty -pn developer-dashboard -pv off

Enable on Demand (Recommended approach will be OnDemand)

stsadm -o setproperty -pn developer-dashboard -pv OnDemand

Enable developer dashboard SharePoint using Server Object Model

By using SharePoint server object model, we may do the enable or disable developer dashboard in SharePoint as below,

using Microsoft.SharePoint;  
using Microsoft.SharePoint.Administration;  
SPDeveloperDashboardSettings settings = SPWebService.ContentService.DeveloperDashboardSettings;  
settings.DisplayLevel = SPDeveloperDashboardLevel.On;  
settings.TraceEnabled = true;  
settings.Update();

using Microsoft.SharePoint;

using Microsoft.SharePoint.Administration;

SPDeveloperDashboardSettings settings = SPWebService.ContentService.DeveloperDashboardSettings;

settings.DisplayLevel = SPDeveloperDashboardLevel.On;

settings.TraceEnabled = true;

settings.Update();

Developer Dashboard on custom master page in SharePoint

To use Developer Dashboard on custom master pages, keep the Developer Dashboard Launcher and page rendering control on the custom master page.

For the developer dashboard launcher,

<Sharepoint:DeveloperDashboardLauncher ID="DeveloperDashboardLauncher" NavigateUrl="javascript:ToggleDeveloperDashboard()" runat="server" ImageUrl="/_layouts/images/fgimg.png" Text="<%$Resources:wss,multipages_launchdevdashalt_text%>" OffsetX=0 OffsetY=222 Height=16 Width=16 />

1	<Sharepoint:DeveloperDashboardLauncher ID="DeveloperDashboardLauncher" NavigateUrl="javascript:ToggleDeveloperDashboard()" runat="server" ImageUrl="/_layouts/images/fgimg.png" Text="<%$Resources:wss,multipages_launchdevdashalt_text%>" OffsetX=0 OffsetY=222 Height=16 Width=16 />

Page Rendering Control

<SharePoint:DeveloperDashboard runat="server" />

1	<SharePoint:DeveloperDashboard runat="server" />

Where on the page it will reflect and render the output.

Viewing Logs with Developer Dashboard

Using the below steps, we can view the ULS logs in developer dashboard.

Log to your site
From the right side of the ribbon, click on developer dashboard. Developer dashboard will pop up in new window.
Browse the link to troubleshoot. It will start logging the session requests.
Select the request you want to investigate and click on related ULS log entries.

Recommendation

Most important, it gets enabled to the whole farm and is not particular to any site collection. So, it’s recommended to use in test environments. Then turn it off in production environments.

SharePoint 2013 Hosting – HostForLIFE.eu :: Filtered/Connected Web Parts In Modern SharePoint Pages

Sep 17th

Posted by Peter in European SharePoint 2013 Hosting

For SharePoint power users, the Filtered/Connected Web parts is a very popular feature. While this feature has been in use in Classic SharePoint sites for a long time, it has been a more recent introduction to Modern SharePoint Pages. While the features in Modern SharePoint Pages may not be the same as in Classic SharePoint, I like the fact that the current web parts cover the most relevant functionalities used in Classic SharePoint sites.

Following are the filtered/connected web parts that are available in Modern SharePoint Pages as of today. Further in this article, I will explain how to use each one of them.

List Properties Web part: Displays properties of selected List Item
File Viewer Web part: Displays file content of selected document in Library
Embed Web part: Displays any type of content including Images and Videos
Filter Web part based on another list or library

List Properties Web Part

This web part is useful when users have a list with too many columns and you cannot display the relevant columns in a view without horizontal scrolling. List Properties web part allows users to configure the columns they want to display in a web part when a particular item is selected in List View web part. Here’s how to configure it,

Add a “List Web part” (select a List from the site) and “List Properties Web part” on the page
On the “List Properties Web part”, click “Connect”, it will open the properties pane of the web part
In the properties pane, click on the ellipsis (…), and click “Connect to source”
If you have more than one “List Web part” on the page, then select appropriate web part/list and choose the columns you want to display in the “List Properties Web part”
You can also select if properties should be editable or read-only in the web part
Save the page and test the webpart by selecting any item from “List Web part”

File Viewer Web Part

This web part allows users see the content of a selected file without a need to open each file in browser/desktop app. Here’s how to configure it,

Add a “Document Library Web part” (select a Document Library from the site) and “File Viewer Web part” on the page
On the “File Viewer Web part”, click “Edit”, it will open the properties pane of the web part
In the properties pane, click on the ellipsis (…), and click “Connect to source”
If you have more than one “Document Library Web part” on the page, then select appropriate web part/document library
Save the page and test the webpart by selecting any document from “Document Library Web part”

File Viewer Web part supports various file types apart from Office Documents like Images, Text and PDF.

Embed Web Part

This web part allows users to display dynamic content using links or embed code that can use variables. Below are a couple examples on how to configure it for Images; similar logic can be applied for other content too like YouTube Videos.

Create a List, add a Hyperlink Column to it that will contain the Image URL
Add a “List Web part” (select the List with Image URL’s) and “Embed Web part” on the page
On the “Embed Web part”, click “Edit”, it will open the properties pane of the web part
In the properties pane, click on the ellipsis (…), and click “Connect to source”, then select appropriate web part/list
Under “Web site address or embed code”, add the embed code. In this example, the embed code is,

<iframe width=”693″ height=”390″ src=”[$Image URL]” frameborder=”0″ ></iframe> where [$Image URL] is the variable that represents the column name for the Image URLs.

Save the page and test the web part by selecting any item from “List Web part”. Respective Image will be displayed in Embed Web part

Filter Web Part based on another list or library

This is the same feature as Connected Web parts in Classic SharePoint Sites. In Modern Experience, we enable the “Dynamic Filtering” on the secondary web part and provide the details on the filter. Here is how to do this,

In order to have the dynamic filtering capabilities between two lists, there should be some kind of parent-child relationship that will allow the filters to work
Add a “List” or “Document Library” web part to the page that will act as the parent control
Add another “List” or “Document Library” web part to the page. This will be the child control.
On the second web part, click “Edit”
In the properties pane, enable the “Dynamic Filtering” toggle and provide the column to filter on
Select the Parent List and the column to filter by
Click on “Apply”
Save the page and test the web part by selecting any item/document from parent “List Web part”. Items in the second “List Web part” will be filtered accordingly.

These are some very useful web parts that makes the user experience and content rendering very friendly for end users. If you have not explored these web part features yet, then I encourage you to try them out now in Modern SharePoint Pages.

SharePoint 2013 Hosting – HostForLIFE.eu :: Upload Large File As Chunks In SharePoint Online Using Angular

Mar 20th

Posted by Peter in European SharePoint 2013 Hosting

This article will help you upload the large files in the SharePoint online library into smaller chunks. This article is based on the article, Programmatically Uploading Large Files In SharePoint Online, with some enhancement.

It will walk through step-by-step how to upload the file in SharePoint Online.

Step 1

Create a library in Sharepoint online, eg. Name it Test_ABC.

Step 2

Install Node.js from here

Step 3

Create an Angular project(LargeFileUpload) using AngularCLI

Step 4

Create a proxy setting for Angular with Sharepoint online using my blog Proxy With Angular 6+ And SharePoint Environment.

Step 5

Create a FileUpload Component using the below Command

ng g c FileUpload

1	ng g c FileUpload

Step 6

Create a FileUpload and GlobalServices services using the following commandL

ng g s services/FileUpload  
ng g s services/GlobalService

1 2	ng g s services/FileUpload ng g s services/GlobalService

ng g s services/FileUpload  
ng g s services/GlobalService

1 2	ng g s services/FileUpload ng g s services/GlobalService

GlobalServices.ts

export class GlobalServiceService {  
  constructor() { }  
  public sharePointPageObject = {  
    webAbsoluteUrl: '',  
    webRelativeUrl : '',  
    userId: 0  
  };  
}

export class GlobalServiceService {

constructor() { }

public sharePointPageObject = {

webAbsoluteUrl: '',

webRelativeUrl : '',

userId: 0

};

}

app.component.ts

import { Component } from '@angular/core';  
import { GlobalServiceService } from './services/global-service.service';  
declare const _spPageContextInfo;  
@Component({  
  selector: 'app-root',  
  templateUrl: './app.component.html',  
  styleUrls: ['./app.component.css']  
})  
export class AppComponent {  
  constructor(  
    private globalService: GlobalServiceService  
  ) { }  
  ngOnInit() {  
    this.globalService.sharePointPageObject.webAbsoluteUrl = window.location.href.indexOf('localhost') > -1 ? '/Your sitecollection'  
      : _spPageContextInfo.webAbsoluteUrl;  
    this.globalService.sharePointPageObject.webRelativeUrl = window.location.href.indexOf('localhost') > -1 ? '/Your sitecollection'  
      : _spPageContextInfo.webRelativeUrl;  
    this.globalService.sharePointPageObject.userId = window.location.href.indexOf('localhost') > -1 ? 22 : _spPageContextInfo.userId;  
  }  
}

import { Component } from '@angular/core';

import { GlobalServiceService } from './services/global-service.service';

declare const _spPageContextInfo;

@Component({

selector: 'app-root',

templateUrl: './app.component.html',

styleUrls: ['./app.component.css']

})

export class AppComponent {

constructor(

private globalService: GlobalServiceService

) { }

ngOnInit() {

this.globalService.sharePointPageObject.webAbsoluteUrl = window.location.href.indexOf('localhost') > -1 ? '/Your sitecollection'

: _spPageContextInfo.webAbsoluteUrl;

this.globalService.sharePointPageObject.webRelativeUrl = window.location.href.indexOf('localhost') > -1 ? '/Your sitecollection'

: _spPageContextInfo.webRelativeUrl;

this.globalService.sharePointPageObject.userId = window.location.href.indexOf('localhost') > -1 ? 22 : _spPageContextInfo.userId;

}

Once the template for file upload is created, then update the file-upload.component.html

File Upload: <input placeholder=“Upload File” type=“file” (change)=“largeFileUpload($event)”>

Then file-upload.component.ts as:

import { Component, OnInit } from '@angular/core';  
import { FileUploadService } from '../services/file-upload.service';  
  
@Component({  
  selector: 'app-file-upload',  
  templateUrl: './file-upload.component.html',  
  styleUrls: ['./file-upload.component.css']  
})  
export class FileUploadComponent implements OnInit {  
  
  constructor(  
    private fileUploadService: FileUploadService  
  ) { }  
  
  ngOnInit() {  
  }  
  largeFileUpload(event: any) {  
    let fileList: FileList = event.target.files;  
    if (fileList.length != 0) {  
      this.fileUploadService.fileUpload(fileList[0], "Test_ABC", fileList[0].name).then(addFileToFolder => {  
        console.log("Large File Uploaded Successfully");  
      }).catch(error => {  
        console.log("Error while uploading" + error);  
      });  
    }  
  }  
}

import { Component, OnInit } from '@angular/core';

import { FileUploadService } from '../services/file-upload.service';

@Component({

selector: 'app-file-upload',

templateUrl: './file-upload.component.html',

styleUrls: ['./file-upload.component.css']

})

export class FileUploadComponent implements OnInit {

constructor(

private fileUploadService: FileUploadService

) { }

ngOnInit() {

}

largeFileUpload(event: any) {

let fileList: FileList = event.target.files;

if (fileList.length != 0) {

this.fileUploadService.fileUpload(fileList[0], "Test_ABC", fileList[0].name).then(addFileToFolder => {

console.log("Large File Uploaded Successfully");

}).catch(error => {

console.log("Error while uploading" + error);

});

}

file-upload.services.ts

import { Injectable } from '@angular/core';  
import { GlobalServiceService } from './global-service.service';  
import { HttpClient, HttpErrorResponse } from '@angular/common/http';  
declare const $: any;  
@Injectable({  
  providedIn: 'root'  
})  
export class FileUploadService {  
  
  constructor(  
    private globalService: GlobalServiceService,  
    private httpClient: HttpClient  
  ) { }  
  public siteUrl: string = this.globalService.sharePointPageObject.webAbsoluteUrl;  
  public siteRelativeUrl: string = this.globalService.sharePointPageObject.webAbsoluteUrl != "/" ? this.globalService.sharePointPageObject.webAbsoluteUrl : "";  
  public fileUpload(file: any, documentLibrary: string, fileName: string) {  
    return new Promise((resolve, reject) => {  
      this.createDummyFile(fileName, documentLibrary).then(result => {  
        let fr = new FileReader();  
        let offset = 0;  
        // the total file size in bytes...    
        let total = file.size;  
        // 1MB Chunks as represented in bytes (if the file is less than a MB, seperate it into two chunks of 80% and 20% the size)...    
        let length = 1000000 > total ? Math.round(total * 0.8) : 1000000  
        let chunks = [];  
        //reads in the file using the fileReader HTML5 API (as an ArrayBuffer) - readAsBinaryString is not available in IE!    
        fr.readAsArrayBuffer(file);  
        fr.onload = (evt: any) => {  
          while (offset < total) {  
            //if we are dealing with the final chunk, we need to know...    
            if (offset + length > total) {  
              length = total - offset;  
            }  
            //work out the chunks that need to be processed and the associated REST method (start, continue or finish)    
            chunks.push({  
              offset,  
              length,  
              method: this.getUploadMethod(offset, length, total)  
            });  
            offset += length;  
          }  
          //each chunk is worth a percentage of the total size of the file...    
           const chunkPercentage = (total / chunks.length) / total * 100;  
          console.log("Chunk Percentage: "+chunkPercentage);  
          if (chunks.length > 0) {  
            //the unique guid identifier to be used throughout the upload session    
            const id = this.generateGUID();  
            //Start the upload - send the data to S    
            this.uploadFile(evt.target.result, id, documentLibrary, fileName, chunks, 0, 0, chunkPercentage, resolve, reject);  
          }  
        };  
      })  
    });  
  }  
  
  createDummyFile(fileName, libraryName) {  
    return new Promise((resolve, reject) => {  
      // Construct the endpoint - The GetList method is available for SharePoint Online only.    
      var serverRelativeUrlToFolder = "decodedurl='" + this.siteRelativeUrl + "/" + libraryName + "'";  
      var endpoint = this.siteUrl + "/_api/Web/GetFolderByServerRelativePath(" + serverRelativeUrlToFolder + ")/files" + "/add(overwrite=true, url='" + fileName + "')"  
      const headers = {  
        "accept": "application/json;odata=verbose"  
      };  
      this.executePost(endpoint, this.convertDataBinaryString(2), headers).then(file => resolve(true)).catch(err => reject(err));  
    });  
  }  
  // Base64 - this method converts the blob arrayBuffer into a binary string to send in the REST request    
  convertDataBinaryString(data) {  
    let fileData = '';  
    let byteArray = new Uint8Array(data);  
    for (var i = 0; i < byteArray.byteLength; i++) {  
      fileData += String.fromCharCode(byteArray[i]);  
    }  
    return fileData;  
  }  
  //this method sets up the REST request and then sends the chunk of file along with the unique indentifier (uploadId)    
  uploadFileChunk(id, libraryPath, fileName, chunk, data, byteOffset) {  
    return new Promise((resolve, reject) => {  
      let offset = chunk.offset === 0 ? '' : ',fileOffset=' + chunk.offset;  
      //parameterising the components of this endpoint avoids the max url length problem in SP (Querystring parameters are not included in this length)    
      let endpoint = this.siteUrl + "/_api/web/getfilebyserverrelativeurl('" + this.siteRelativeUrl + "/" + libraryPath + "/" + fileName + "')/" + chunk.method + "(uploadId=guid'" + id + "'" + offset + ")";  
      const headers = {  
        "Accept": "application/json; odata=verbose",  
        "Content-Type": "application/octet-stream"  
      };  
      this.executePost(endpoint, data, headers).then(offset => resolve(offset)).catch(err => reject(err));  
    });  
  }  
  //the primary method that resursively calls to get the chunks and upload them to the library (to make the complete file)    
  uploadFile(result, id, libraryPath, fileName, chunks, index, byteOffset, chunkPercentage, resolve, reject) {  
    //we slice the file blob into the chunk we need to send in this request (byteOffset tells us the start position)    
    const data = this.convertFileToBlobChunks(result, chunks[index]);  
    //upload the chunk to the server using REST, using the unique upload guid as the identifier    
    this.uploadFileChunk(id, libraryPath, fileName, chunks[index], data, byteOffset).then(value => {  
      const isFinished = index === chunks.length - 1;  
      index += 1;  
      const percentageComplete = isFinished ? 100 : Math.round((index * chunkPercentage));  
      console.log("Percentage Completed:" +percentageComplete)  
      //More chunks to process before the file is finished, continue    
      if (index < chunks.length) {  
        this.uploadFile(result, id, libraryPath, fileName, chunks, index, byteOffset, chunkPercentage, resolve, reject);  
      } else {  
        resolve(value);  
      }  
    }).catch(err => {  
      console.log('Error in uploadFileChunk! ' + err);  
      reject(err);  
    });  
  }  
  //Helper method - depending on what chunk of data we are dealing with, we need to use the correct REST method...    
  getUploadMethod(offset, length, total) {  
    if (offset + length + 1 > total) {  
      return 'finishupload';  
    } else if (offset === 0) {  
      return 'startupload';  
    } else if (offset < total) {  
      return 'continueupload';  
    }  
    return null;  
  }  
  //this method slices the blob array buffer to the appropriate chunk and then calls off to get the BinaryString of that chunk    
  convertFileToBlobChunks(result, chunkInfo) {  
    return result.slice(chunkInfo.offset, chunkInfo.offset + chunkInfo.length);  
  }  
  generateGUID() {  
    function s4() {  
      return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);  
    }  
    return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();  
  }  
  async executePost(url, data, requestHeaders) {  
    const res = await this.httpClient.post(url, data, requestHeaders).toPromise().catch((err: HttpErrorResponse) => {  
      const error = err.error;  
      return error;  
    });  
    return this.parseRetSingle(res);  
  }  
  parseRetSingle(res) {  
    if (res) {  
      if (res.hasOwnProperty('d')) {  
        return res.d;  
      } else if (res.hasOwnProperty('error')) {  
        const obj: any = res.error;  
        obj.hasError = true;  
        return obj;  
      } else {  
        return {  
          hasError: true,  
          comments: res  
        };  
      }  
    } else {  
      return {  
        hasError: true,  
        comments: 'Check the response in network trace'  
      };  
    }  
  }  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

import { Injectable } from '@angular/core';

import { GlobalServiceService } from './global-service.service';

import { HttpClient, HttpErrorResponse } from '@angular/common/http';

declare const $: any;

@Injectable({

providedIn: 'root'

})

export class FileUploadService {

constructor(

private globalService: GlobalServiceService,

private httpClient: HttpClient

) { }

public siteUrl: string = this.globalService.sharePointPageObject.webAbsoluteUrl;

public siteRelativeUrl: string = this.globalService.sharePointPageObject.webAbsoluteUrl != "/" ? this.globalService.sharePointPageObject.webAbsoluteUrl : "";

public fileUpload(file: any, documentLibrary: string, fileName: string) {

return new Promise((resolve, reject) => {

this.createDummyFile(fileName, documentLibrary).then(result => {

let fr = new FileReader();

let offset = 0;

// the total file size in bytes...

let total = file.size;

// 1MB Chunks as represented in bytes (if the file is less than a MB, seperate it into two chunks of 80% and 20% the size)...

let length = 1000000 > total ? Math.round(total * 0.8) : 1000000

let chunks = [];

//reads in the file using the fileReader HTML5 API (as an ArrayBuffer) - readAsBinaryString is not available in IE!

fr.readAsArrayBuffer(file);

fr.onload = (evt: any) => {

while (offset < total) {

//if we are dealing with the final chunk, we need to know...

if (offset + length > total) {

length = total - offset;

}

//work out the chunks that need to be processed and the associated REST method (start, continue or finish)

chunks.push({

offset,

length,

method: this.getUploadMethod(offset, length, total)

});

offset += length;

}

//each chunk is worth a percentage of the total size of the file...

const chunkPercentage = (total / chunks.length) / total * 100;

console.log("Chunk Percentage: "+chunkPercentage);

if (chunks.length > 0) {

//the unique guid identifier to be used throughout the upload session

const id = this.generateGUID();

//Start the upload - send the data to S

this.uploadFile(evt.target.result, id, documentLibrary, fileName, chunks, 0, 0, chunkPercentage, resolve, reject);

}

};

})

});

}

createDummyFile(fileName, libraryName) {

return new Promise((resolve, reject) => {

// Construct the endpoint - The GetList method is available for SharePoint Online only.

var serverRelativeUrlToFolder = "decodedurl='" + this.siteRelativeUrl + "/" + libraryName + "'";

var endpoint = this.siteUrl + "/_api/Web/GetFolderByServerRelativePath(" + serverRelativeUrlToFolder + ")/files" + "/add(overwrite=true, url='" + fileName + "')"

const headers = {

"accept": "application/json;odata=verbose"

};

this.executePost(endpoint, this.convertDataBinaryString(2), headers).then(file => resolve(true)).catch(err => reject(err));

});

}

// Base64 - this method converts the blob arrayBuffer into a binary string to send in the REST request

convertDataBinaryString(data) {

let fileData = '';

let byteArray = new Uint8Array(data);

for (var i = 0; i < byteArray.byteLength; i++) {

fileData += String.fromCharCode(byteArray[i]);

}

return fileData;

}

//this method sets up the REST request and then sends the chunk of file along with the unique indentifier (uploadId)

uploadFileChunk(id, libraryPath, fileName, chunk, data, byteOffset) {

return new Promise((resolve, reject) => {

let offset = chunk.offset === 0 ? '' : ',fileOffset=' + chunk.offset;

//parameterising the components of this endpoint avoids the max url length problem in SP (Querystring parameters are not included in this length)

let endpoint = this.siteUrl + "/_api/web/getfilebyserverrelativeurl('" + this.siteRelativeUrl + "/" + libraryPath + "/" + fileName + "')/" + chunk.method + "(uploadId=guid'" + id + "'" + offset + ")";

const headers = {

"Accept": "application/json; odata=verbose",

"Content-Type": "application/octet-stream"

};

this.executePost(endpoint, data, headers).then(offset => resolve(offset)).catch(err => reject(err));

});

}

//the primary method that resursively calls to get the chunks and upload them to the library (to make the complete file)

uploadFile(result, id, libraryPath, fileName, chunks, index, byteOffset, chunkPercentage, resolve, reject) {

//we slice the file blob into the chunk we need to send in this request (byteOffset tells us the start position)

const data = this.convertFileToBlobChunks(result, chunks[index]);

//upload the chunk to the server using REST, using the unique upload guid as the identifier

this.uploadFileChunk(id, libraryPath, fileName, chunks[index], data, byteOffset).then(value => {

const isFinished = index === chunks.length - 1;

index += 1;

const percentageComplete = isFinished ? 100 : Math.round((index * chunkPercentage));

console.log("Percentage Completed:" +percentageComplete)

//More chunks to process before the file is finished, continue

if (index < chunks.length) {

this.uploadFile(result, id, libraryPath, fileName, chunks, index, byteOffset, chunkPercentage, resolve, reject);

} else {

resolve(value);

}

}).catch(err => {

console.log('Error in uploadFileChunk! ' + err);

reject(err);

});

}

//Helper method - depending on what chunk of data we are dealing with, we need to use the correct REST method...

getUploadMethod(offset, length, total) {

if (offset + length + 1 > total) {

return 'finishupload';

} else if (offset === 0) {

return 'startupload';

} else if (offset < total) {

return 'continueupload';

}

return null;

}

//this method slices the blob array buffer to the appropriate chunk and then calls off to get the BinaryString of that chunk

convertFileToBlobChunks(result, chunkInfo) {

return result.slice(chunkInfo.offset, chunkInfo.offset + chunkInfo.length);

}

generateGUID() {

function s4() {

return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1);

}

return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4();

}

async executePost(url, data, requestHeaders) {

const res = await this.httpClient.post(url, data, requestHeaders).toPromise().catch((err: HttpErrorResponse) => {

const error = err.error;

return error;

});

return this.parseRetSingle(res);

}

parseRetSingle(res) {

if (res) {

if (res.hasOwnProperty('d')) {

return res.d;

} else if (res.hasOwnProperty('error')) {

const obj: any = res.error;

obj.hasError = true;

return obj;

} else {

return {

hasError: true,

comments: res

};

}

} else {

return {

hasError: true,

comments: 'Check the response in network trace'

};

}

Finally, run the code using the command:

npm run start

1	npm run start

Now, your requests will be served at http://localhost:4200/.

SharePoint 2013 Hosting – HostForLIFE.eu :: Read Large Lists in SharePoint Framework

Mar 6th

Posted by Peter in European SharePoint 2013 Hosting

Reading large lists always has been a challenge for SharePoint developers. This is one of those instances where the on-premises environment is appreciated by SharePoint developers, as SharePoint administrators can come to their rescue by adjusting the query threshold limit in Central Administration. The other commonly used approaches from the developer are to limit the items in view, index the columns, etc. This workaround reduces the pain to a certain extent but not fully. Unfortunately, we do not have much administration liberty in SharePoint Online to play around with threshold limits. In this article, we will revise the threshold concept and various approaches to read the large lists programmatically in SharePoint Framework.

Threshold

Let’s quickly revise the term Threshold. To build information architecture for SharePoint, it is important to understand the SharePoint online limitations and boundaries. Which says, the list items limit is 30 Million. That’s very very huge.

Every time you access a list or document library, a search query happens behind the scenes that return all the results. For example, if you have 50,000 items in a list, when you try to show them in a single view or programmatically retrieve those in a single query, you won’t be able to get more than 5,000 items. We can say the list/library is facing the 5,000 item limit threshold. The threshold limit with SharePoint Online is still 5,000.

Do not confuse the threshold of 5,000 items with the list capacity which is 30 Million.

Get around with Threshold

PnP JS is the popular library amongst SPFx developers for SharePoint operations. It provides some cool methods to get around the threshold issues.

Example# 1: Basic usage

pnp.sp.web.lists.getByTitle("BigList").items.getAll().then((allItems: any[]) => {  
     // how many did we get  
     console.log(allItems.length);  
});

pnp.sp.web.lists.getByTitle("BigList").items.getAll().then((allItems: any[]) => {

// how many did we get

console.log(allItems.length);

});

Example# 2: Set page size

pnp.sp.web.lists.getByTitle("BigList").items.getAll(4000).then((allItems: any[]) => {  
     // how many did we get  
     console.log(allItems.length);  
});

pnp.sp.web.lists.getByTitle("BigList").items.getAll(4000).then((allItems: any[]) => {

// how many did we get

console.log(allItems.length);

});

Example# 3: Use select and top. top will set page size and override the any value passed to getAll

pnp.sp.web.lists.getByTitle("BigList").items.select("Title").top(4000).getAll().then((allItems: any[]) => {  
     // how many did we get  
     console.log(allItems.length);  
});

pnp.sp.web.lists.getByTitle("BigList").items.select("Title").top(4000).getAll().then((allItems: any[]) => {

// how many did we get

console.log(allItems.length);

});

Example# 4: Use filter as a supported odata operation

pnp.sp.web.lists.getByTitle("BigList").items.select("Title").filter("Title eq 'Test'").getAll().then((allItems: any[]) => {  
     // how many did we get  
     console.log(allItems.length);  
});

pnp.sp.web.lists.getByTitle("BigList").items.select("Title").filter("Title eq 'Test'").getAll().then((allItems: any[]) => {

// how many did we get

console.log(allItems.length);

});

But, this will likely fail on large lists.

Custom Implementation

Here is another approach to get read the large list with paging implementation.

Consider we have a SharePoint list named “LargeList” with below schema:

Field Name	Type
Title	Single line of text
Description	Multiple lines of text
Category	Single line of text
Quantity	Number

The model to represent above list will be as below:

export interface ILargeListItem {  
     Title: string;  
     Description: string;  
     Category: string;  
     Quantity: number;  
}

export interface ILargeListItem {

Title: string;

Description: string;

Category: string;

Quantity: number;

}

Let us define our approach to handle large list:

We will define the page size as 5000 for example (maximum threshold limit). Please note, SharePoint internally fetches the items in the batch of 100 items.
The number of requests we will have to read entire large list will be: Number of list items / page size.
We will make asynchronous requests to read the list items in batch.
Wait for all asynchronous requests to finish

Implement a genetic method getPageListItems which returns items with paging, starting with index passed as an argument.

skiptoken=Paged=TRUE%26p_ID=` + (index * Constants.Page_Size + 1)

1	skiptoken=Paged=TRUE%26p_ID=` + (index * Constants.Page_Size + 1)

The getPageListItems method implementation will look as follows:

private getPageListItems(listTitle: string, index: number): Promise<ILargeListItem[]> {  
    return new Promise<ILargeListItem[]>((resolve, reject): void => {  
    let requestUrl = this.context.pageContext.web.absoluteUrl  
        + `/_api/web/Lists/GetByTitle('` + listTitle + `')/items`  
        + `?$skiptoken=Paged=TRUE%26p_ID=` + (index * Constants.Page_Size + 1)  
        + `&$top=` + Constants.Page_Size  
        + `&$select=ID,Title,Description,Category,Quantity`;  
  
    this.context.spHttpClient.get(requestUrl, SPHttpClient.configurations.v1)  
    .then((response: SPHttpClientResponse) => {  
        response.json().then((responseJSON: any) => {    
            resolve(responseJSON.value);    
          });    
        });  
    });   
}

private getPageListItems(listTitle: string, index: number): Promise<ILargeListItem[]> {

return new Promise<ILargeListItem[]>((resolve, reject): void => {

let requestUrl = this.context.pageContext.web.absoluteUrl

+ `/_api/web/Lists/GetByTitle('` + listTitle + `')/items`

+ `?$skiptoken=Paged=TRUE%26p_ID=` + (index * Constants.Page_Size + 1)

+ `&$top=` + Constants.Page_Size

+ `&$select=ID,Title,Description,Category,Quantity`;

this.context.spHttpClient.get(requestUrl, SPHttpClient.configurations.v1)

.then((response: SPHttpClientResponse) => {

response.json().then((responseJSON: any) => {

resolve(responseJSON.value);

});

}

Implement a method to get the latest item id. This will be our maximum limit to read the items.

public getLatestItemId(listTitle: string): Promise<number> {  
    return new Promise<number>((resolve: (itemId: number) => void, reject: (error: any) => void): void => {  
        sp.web.lists.getByTitle(listTitle)  
            .items.orderBy('Id', false).top(1).select('Id').get()  
            .then((items: { Id: number }[]): void => {  
                if (items.length === 0) {  
                    resolve(-1);  
                }  
                else {  
                    resolve(items[0].Id);  
                }  
            }, (error: any): void => {  
                reject(error);  
            });  
    });  
}

public getLatestItemId(listTitle: string): Promise<number> {

return new Promise<number>((resolve: (itemId: number) => void, reject: (error: any) => void): void => {

sp.web.lists.getByTitle(listTitle)

.items.orderBy('Id', false).top(1).select('Id').get()

.then((items: { Id: number }[]): void => {

if (items.length === 0) {

resolve(-1);

}

else {

resolve(items[0].Id);

}

}, (error: any): void => {

reject(error);

});

}

The next step is to implement method the main method to make asynchronous requests to read the list items in batch.

public async getLargeListItems(listTitle: string): Promise<ILargeListItem[]> {  
    var largeListItems: ILargeListItem[] = [];  
  
    return new Promise<ILargeListItem[]>(async (resolve, reject) => {  
        // Array to hold async calls  
        const asyncFunctions = [];  
  
        this.getLatestItemId(listTitle).then(async (itemCount: number) => {  
            for (let i = 0; i < Math.ceil(itemCount / Constants.Page_Size); i++) {  
                // Make multiple async calls  
                let resolvePagedListItems = () => {  
                    return new Promise(async (resolve) => {  
                        let pagedItems:ILargeListItem[] = await this.getPageListItems(listTitle, i);  
                        resolve(pagedItems);  
                    })  
                };  
                asyncFunctions.push(resolvePagedListItems());  
            }  
  
                       // Wait for all async calls to finish  
            const results: any = await Promise.all(asyncFunctions);  
            for (let i = 0; i < results.length; i++) {  
                largeListItems = largeListItems.concat(results[i]);  
            }  
  
            resolve(largeListItems);  
        });  
    });  
}

public async getLargeListItems(listTitle: string): Promise<ILargeListItem[]> {

var largeListItems: ILargeListItem[] = [];

return new Promise<ILargeListItem[]>(async (resolve, reject) => {

// Array to hold async calls

const asyncFunctions = [];

this.getLatestItemId(listTitle).then(async (itemCount: number) => {

for (let i = 0; i < Math.ceil(itemCount / Constants.Page_Size); i++) {

// Make multiple async calls

let resolvePagedListItems = () => {

return new Promise(async (resolve) => {

let pagedItems:ILargeListItem[] = await this.getPageListItems(listTitle, i);

resolve(pagedItems);

})

};

asyncFunctions.push(resolvePagedListItems());

}

// Wait for all async calls to finish

const results: any = await Promise.all(asyncFunctions);

for (let i = 0; i < results.length; i++) {

largeListItems = largeListItems.concat(results[i]);

}

resolve(largeListItems);

});

}

Summary

Reading large lists always has been a challenge for SharePoint developers. There are various approaches to read the large lists programmatically in SharePoint Framework. We explored the options to read large lists with PnP JS as well a custom implementation with paging approach.

SharePoint 2013 Hosting – HostForLIFE.eu :: How To Get Current Context From SharePoint Modern Site Page?

Feb 27th

Posted by Peter in European SharePoint 2013 Hosting

Today we will see how to get the current context information from Modern Pages. In Classical Pages and anything other than modern site pages, we can get the current web and user context information using the _spPageContextInfo variable.

But when we try to access the same variable in modern site pages, we will get an undefined error. If we change the page to view source mode, we will see this _spPageContextInfo JavaScript variable is commented. Due to that we won’t access the current context information.

There is a workaround available and that too has come from SharePoint. We must use the full Modern Page URL to send the request along with “as=json” as a query string.

Format of the Request URL,

http://domaoin.sharepoint.com/sites/name/sitepages/modernpage.aspx
http://domaoin.sharepoint.com/sites/name – If the modern page is the home page of the site

To test this, navigate to the modern site page. Then open the browser console and paste the below code snippet,

//Reference URL https://gist.github.com/ktskumar/ab378261b9f7d349254043dc935c08d9#file-getmodernpagecontext-js   
  
//getRequest method reference  - https://gist.github.com/ktskumar/a9e9df497673e9fd26ead8532b9ff425   
function getRequest(url) {    
    var request = new XMLHttpRequest();    
    return new Promise(function(resolve, reject) {    
        request.onreadystatechange = function() {    
            if (request.readyState !== 4) return;    
            if (request.status >= 200 && request.status < 300) {    
                resolve(request);    
            } else {    
                reject({    
                    status: request.status,    
                    statusText: request.statusText    
                });    
            }    
        };    
    
        request.open('GET', url, true);    
        request.setRequestHeader("Content-Type", "application/json;charset=utf-8");    
        request.setRequestHeader("ACCEPT", "application/json; odata.metadata=minimal");    
        request.setRequestHeader("ODATA-VERSION", "4.0");    
        request.send();    
    
    });    
}    
    
//Get the Request location from the browser URL    
var path = location.href.replace(location.search, "") + "?as=json";    
    
//Returns the current user, item, page and context information    
getRequest(path).then(function(response) {    
    console.log(JSON.parse(response.response));    
});

//Reference URL https://gist.github.com/ktskumar/ab378261b9f7d349254043dc935c08d9#file-getmodernpagecontext-js

//getRequest method reference - https://gist.github.com/ktskumar/a9e9df497673e9fd26ead8532b9ff425

function getRequest(url) {

var request = new XMLHttpRequest();

return new Promise(function(resolve, reject) {

request.onreadystatechange = function() {

if (request.readyState !== 4) return;

if (request.status >= 200 && request.status < 300) {

resolve(request);

} else {

reject({

status: request.status,

statusText: request.statusText

});

}

};

request.open('GET', url, true);

request.setRequestHeader("Content-Type", "application/json;charset=utf-8");

request.setRequestHeader("ACCEPT", "application/json; odata.metadata=minimal");

request.setRequestHeader("ODATA-VERSION", "4.0");

request.send();

});

}

//Get the Request location from the browser URL

var path = location.href.replace(location.search, "") + "?as=json";

//Returns the current user, item, page and context information

getRequest(path).then(function(response) {

console.log(JSON.parse(response.response));

});

And it returns the context information of current user, current page properties, current item properties and current web properties.

SharePoint 2013 Hosting – HostForLIFE.eu :: React Toast Notifications In SPFX

Feb 20th

Posted by Peter in European SharePoint 2013 Hosting

The react-toast-notifications is a plugin written in React.js to generate toast notifications in React doms. Since this plugin is written in a React hooks concept, we are not able to use this in class component. Rather, we can use this in functional component.

Open a command prompt. Create a directory for the SPFx solution.

md spfx-ToastNotication

1	md spfx-ToastNotication

Navigate to the above-created directory.

cd spfx-ToastNotication

1	cd spfx-ToastNotication

Run the Yeoman SharePoint Generator to create the solution.

yo @microsoft/sharepoint

1	yo @microsoft/sharepoint

Solution Name

Hit Enter to have the default name (spfx-ToastNotication in this case) or type in any other name for your solution.

Selected choice – Hit Enter

Target for the component

Here, we can select the target environment where we are planning to deploy the client web part; i.e., SharePoint Online or SharePoint OnPremise (SharePoint 2016 onwards).

Selected choice – SharePoint Online only (latest).

Place of files

We may choose to use the same folder or create a subfolder for our solution.

Selected choice – same folder.

Deployment option

Selecting Y will allow the app to be deployed instantly to all sites and be accessible everywhere.

Selected choice – N (install on each site explicitly).

Permissions to access web APIs

Choose if the components in the solution require permission to access web APIs that are unique and not shared with other components in the tenant.

Selected choice – N (solution contains unique permissions)

Type of client-side component to create

We can choose to create a client-side web part or an extension. Choose the web part option.

Selected choice – WebPart

Web part name

Hit Enter to select the default name or type in any other name.

Selected choice – SpfxToast

Web part description

Hit Enter to select the default description or type in any other value.

Framework to use

Select any JavaScript framework to develop the component. Available choices are – No JavaScript Framework, React, and Knockout.

Selected choice – React

The Yeoman generator will perform a scaffolding process to generate the solution. The scaffolding process will take a significant amount of time.

Once the scaffolding process is completed, lock down the version of project dependencies by running the below command,

npm shrinkwrap

1	npm shrinkwrap

In the command prompt, type the below command to open the solution in the code editor of your choice.

NPM Packages Used,

On the command prompt, run the below commands

npm i react-toast-notifications

1	npm i react-toast-notifications

Necessary imports for Toast Notification plugin,

import { ToastProvider, useToasts } from 'react-toast-notifications' ;

1	import { ToastProvider, useToasts } from 'react-toast-notifications' ;

Wrap your ToastComponent in the ToastProvider, which provides context for the Toast descendants.

e.g)

export  const  MyReactToast = ({mycontent}) => (  
    <ToastProvider>  
      <ToastDemo mycontent={mycontent} />  
    </ToastProvider>  
  );

export const MyReactToast = ({mycontent}) => (

</ToastProvider>

);

To intialize the toast notification,

const { addToast } = useToasts();  
addToast(mycontent, {  
     appearance: 'success',  
     autoDismiss: false,  
   }

const { addToast } = useToasts();

addToast(mycontent, {

appearance: 'success',

autoDismiss: false,

}

Available apearance paramters are success, error, warning and info in default autodismiss is false.

You can set autodismiss by providing milliseconds.

<ToastProvider  
        autoDismiss  
        autoDismissTimeout={6000}  
        placement="bottom-center">

<ToastProvider

autoDismiss

autoDismissTimeout={6000}

placement="bottom-center">

The useToasts hook contains following signatures,

const { addToast, removeToast, removeAllToasts, updateToast, toastStack } = useToasts();

1	const { addToast, removeToast, removeAllToasts, updateToast, toastStack } = useToasts();

in SpfxToast.tsx

import * as React from 'react';  
import { ISpfxToastProps } from './ISpfxToastProps';  
import { MyReactToast }from './Reacttoast';  
export default class SpfxToast extends React.Component<ISpfxToastProps, {}> {  
  public render(): React.ReactElement<ISpfxToastProps> {  
    return (  
      <div>  
      <MyReactToast mycontent={"Hello it's Peter"}/>  
        </div>  
    );  
  }  
}

import * as React from 'react';

import { ISpfxToastProps } from './ISpfxToastProps';

import { MyReactToast }from './Reacttoast';

export default class SpfxToast extends React.Component<ISpfxToastProps, {}> {

public render(): React.ReactElement<ISpfxToastProps> {

return (

<div>

</div>

);

}

in Reacttoast.tsx

import * as React from 'react';  
import { ToastProvider,useToasts } from 'react-toast-notifications';  
  
const  ToastDemo  = ({mycontent}) =>{  
  const { addToast } = useToasts();  
  return (  
      <>  
    <button onClick={() => addToast(mycontent, {  
      appearance: 'success',  
      autoDismiss: false,  
      PlacementType :'bottom-left',  
    })}>  
      success Toast  
    </button>  
    <button onClick={() => addToast(mycontent, {  
      appearance: 'error',  
      autoDismiss: false,  
    })}>  
      error Toast  
    </button>  
    <button onClick={() => addToast(mycontent, {  
      appearance: 'warning',  
      autoDismiss: false,  
    })}>  
      warning Toast  
    </button>  
    <button onClick={() => addToast(mycontent, {  
      appearance: 'info',  
      autoDismiss: false,  
    })}>  
      Info Toast  
    </button></>   
      
  );  
};  
export  const  MyReactToast = ({mycontent}) => (  
    <ToastProvider>  
      <ToastDemo mycontent={mycontent} />  
    </ToastProvider>  
  );

import * as React from 'react';

import { ToastProvider,useToasts } from 'react-toast-notifications';

const ToastDemo = ({mycontent}) =>{

const { addToast } = useToasts();

return (

<button onClick={() => addToast(mycontent, {

appearance: 'success',

autoDismiss: false,

PlacementType :'bottom-left',

})}>

success Toast

</button>

<button onClick={() => addToast(mycontent, {

appearance: 'error',

autoDismiss: false,

})}>

error Toast

</button>

<button onClick={() => addToast(mycontent, {

appearance: 'warning',

autoDismiss: false,

})}>

warning Toast

</button>

<button onClick={() => addToast(mycontent, {

appearance: 'info',

autoDismiss: false,

})}>

Info Toast

</button></>

);

};

export const MyReactToast = ({mycontent}) => (

</ToastProvider>

);

Posts tagged trick SharePoint 2013 Hosting

SharePoint 2013 Hosting – HostForLIFE.eu :: Easy Debugging With Developer Dashboard In SharePoint

What is developer dashboard?

Enable developer dashboard SharePoint 2016/2013 using PowerShell script

Enable developer dashboard SharePoint 2010 STSADM

Enable developer dashboard SharePoint using Server Object Model

Developer Dashboard on custom master page in SharePoint

Viewing Logs with Developer Dashboard

SharePoint 2013 Hosting – HostForLIFE.eu :: Filtered/Connected Web Parts In Modern SharePoint Pages

List Properties Web Part

File Viewer Web Part

Embed Web Part

Filter Web Part based on another list or library

SharePoint 2013 Hosting – HostForLIFE.eu :: Upload Large File As Chunks In SharePoint Online Using Angular

SharePoint 2013 Hosting – HostForLIFE.eu :: Read Large Lists in SharePoint Framework

Threshold

Get around with Threshold

Custom Implementation

Summary

SharePoint 2013 Hosting – HostForLIFE.eu :: How To Get Current Context From SharePoint Modern Site Page?

SharePoint 2013 Hosting – HostForLIFE.eu :: React Toast Notifications In SPFX

BLOGROLL

Featured On

Posts tagged trick SharePoint 2013 Hosting

SharePoint 2013 Hosting – HostForLIFE.eu :: Easy Debugging With Developer Dashboard In SharePoint

What is developer dashboard?

Enable developer dashboard SharePoint 2016/2013 using PowerShell script

Enable developer dashboard SharePoint 2010 STSADM

Enable developer dashboard SharePoint using Server Object Model

Developer Dashboard on custom master page in SharePoint

Viewing Logs with Developer Dashboard

SharePoint 2013 Hosting – HostForLIFE.eu :: Filtered/Connected Web Parts In Modern SharePoint Pages

List Properties Web Part

File Viewer Web Part

Embed Web Part

Filter Web Part based on another list or library

SharePoint 2013 Hosting – HostForLIFE.eu :: Upload Large File As Chunks In SharePoint Online Using Angular

SharePoint 2013 Hosting – HostForLIFE.eu :: Read Large Lists in SharePoint Framework

Threshold

Get around with Threshold

Custom Implementation

Summary

SharePoint 2013 Hosting – HostForLIFE.eu :: How To Get Current Context From SharePoint Modern Site Page?

SharePoint 2013 Hosting – HostForLIFE.eu :: React Toast Notifications In SPFX

BLOGROLL

Featured On

Tags