Upload large files via Dataverse

private async uploadFile(fileModel: FileModel): Promise<string> {
    const chunkSize = 4 * 1024 * 1024; //4MB
    const chunks = Array.from({ length: Math.ceil(fileModel.content.length / chunkSize) }, (_, index) =>
	      fileModel.content.slice(index * chunkSize, (index + 1) * chunkSize)
    );
    const base64Guids = [];
    const record: any = {
	      cpl_name: fileModel.name
    };
    let fileStagingId = "";

    for (let i = 0; i < chunks.length; i++) {
	      base64Guids[i] = btoa(newGuid());
    }
    //----------------------------------------------------------CreateRecord---------------------------------
    let fileStaging = await Xrm.WebApi.createRecord("cpl_fileStaging", record);
    fileStagingId = fileStaging.id;
    //----------------------------------------------------------InitializeFileBlocksUpload-------------------
    var execute_InitializeFileBlocksUpload_Request = {
      	Target: { "@odata.type": "Microsoft.Dynamics.CRM.cpl_fileStaging", cpl_fileStagingid: fileStagingId },
      	FileName: fileModel.name,
      	FileAttributeName: "cpl_temporaryfile",
      
      	getMetadata: function () {
      	    return {
            		boundParameter: null,
            		parameterTypes: {
            		    Target: { typeName: "mscrm.crmbaseentity", structuralProperty: 5 },
            		    FileName: { typeName: "Edm.String", structuralProperty: 1 },
            		    FileAttributeName: { typeName: "Edm.String", structuralProperty: 1 }
            		},
            		operationType: 0, operationName: "InitializeFileBlocksUpload"
      	    };
      	}
    };

    Xrm.WebApi.online.execute(execute_InitializeFileBlocksUpload_Request).then(
        function success(response) {
    	      if (response.ok) { return response.json(); }
      	}
    ).then(function (responseBody) {
      	let result = responseBody;
      	let y = 0;
      	let filecontinuationtoken = result["FileContinuationToken"];
      	//------------------------------------------------------UploadBlock----------------------------------
      	for (let i = 0; i < chunks.length; i++) {
      	    let parameters: any = {};
      	    parameters.BlockId = base64Guids[i];
      	    parameters.BlockData = chunks[i];
      	    parameters.FileContinuationToken = filecontinuationtoken;
      
      	    fetch(Xrm.Utility.getGlobalContext().getClientUrl() + "/api/data/v9.2/UploadBlock", {
                method: "POST",
            		headers: {
             		    "OData-MaxVersion": "4.0",
                    "OData-Version": "4.0",
                    "Content-Type": "application/json; charset=utf-8",
                    "Accept": "application/json"
                },
              	body: JSON.stringify(parameters)
            }).then(
                function success(response) {
                    if (response.ok) {
                   			//--------------------------------------CommitFileBlocksUpload-----------------------
                  			y++;
                  			if (y == chunks.length) {
                  			    let parameters: any = {};
                  			    parameters.FileName = fileModel.name;
                  			    parameters.MimeType = fileModel.mimeType;
                  			    parameters.BlockList = base64Guids;
                  			    parameters.FileContinuationToken = filecontinuationtoken;
                  
                        		fetch(Xrm.Utility.getGlobalContext().getClientUrl() + "/api/data/v9.2/CommitFileBlocksUpload", {
                        				method: "POST",
                        				headers: {
                        				    "OData-MaxVersion": "4.0",
                        				    "OData-Version": "4.0",
                        				    "Content-Type": "application/json; charset=utf-8",
                        				    "Accept": "application/json"
                        				},
                        				body: JSON.stringify(parameters)
                  			    }).then(
                  			      	function success(response) {
                  				          return response.json().then((json) => { if (response.ok) { return [response, json]; } else { throw json.error; } });
                  				      }
                  				  ).then(function (responseObjects) {
                  			      	let responseBody = responseObjects[1];
                  			    }).catch(function (error) {
                  				      console.error(error.message);
                  			    });
                  			}
              			    //CommitFileBlocksUpload end
          		      } else {
          			        return response.json().then((json) => { throw json.error; });
          	   	    }
	            	}
	          ).catch(function (error) {
		            console.error(error.message);
	          });
	      }
  	    //Upload Block end
    }).catch(function (error) {
	      console.log(error.message);
    });
    return fileStagingId;}

private static byte[] DownloadFile(PluginProcessService processService, IOrganizationService service, EntityReference entityReference, string attributeName)
{
    InitializeFileBlocksDownloadRequest initializeFileBlocksDownloadRequest = new InitializeFileBlocksDownloadRequest()
    {
	      Target = entityReference,
	      FileAttributeName = attributeName
    };
    int numberoOfTries = 0;
    int maxReentries = 40;
    bool success = false;

    var initializeFileBlocksDownloadResponse = new InitializeFileBlocksDownloadResponse();

    while ((numberoOfTries < maxReentries) && !success)
    {
	      try
	      {
	          initializeFileBlocksDownloadResponse = (InitializeFileBlocksDownloadResponse)service.Execute(initializeFileBlocksDownloadRequest);
	          success = true;
	      }
	      catch
	      {
	          numberoOfTries++;
	      }
	      finally
	      {
	          Thread.Sleep(1000);
	      }
    }

    string fileContinuationToken = initializeFileBlocksDownloadResponse.FileContinuationToken;
    long fileSizeInBytes = initializeFileBlocksDownloadResponse.FileSizeInBytes;
    List<byte> fileBytes = new List<byte>((int)fileSizeInBytes);
    long offset = 0;
    long blockSizeDownload = 4 * 1024 * 1024; //4MB

    if (fileSizeInBytes < blockSizeDownload)
    {
      	blockSizeDownload = fileSizeInBytes;
    }
    while (fileSizeInBytes > 0)
    {
	      DownloadBlockRequest downLoadBlockRequest = new DownloadBlockRequest()
	      {
	          BlockLength = blockSizeDownload,
	          FileContinuationToken = fileContinuationToken,
	         Offset = offset
	      };

	      var downloadBlockResponse = (DownloadBlockResponse)service.Execute(downLoadBlockRequest);
      	fileBytes.AddRange(downloadBlockResponse.Data);
      	fileSizeInBytes -= (int)blockSizeDownload;
      	offset += blockSizeDownload;
    }
    return fileBytes.ToArray();
}