Codeunit 9123 SharePoint Graph Req. Helper

System Application, System.Integration.Sharepoint

src/System Application/App/SharePoint/src/graph/helpers/SharePointGraphReqHelper.Codeunit.al649 lines, Copyright (c) Microsoft Corporation. MIT

// ------------------------------------------------------------------------------------------------// Copyright (c) Microsoft Corporation. All rights reserved.// Licensed under the MIT License. See License.txt in the project root for license information.// ------------------------------------------------------------------------------------------------namespace System.Integration.Sharepoint;using System.Integration.Graph;using System.Integration.Graph.Authorization;using System.RestClient;using System.Utilities;/// <summary>/// Provides functionality for making requests to the Microsoft Graph API for SharePoint./// </summary>codeunit 9123 "SharePoint Graph Req. Helper"{    Access = Internal;    InherentEntitlements = X;    InherentPermissions = X;    var        GraphClient: Codeunit "Graph Client";        SharePointDiagnostics: Codeunit "SharePoint Diagnostics";        ApiVersion: Enum "Graph API Version";        CustomBaseUrl: Text;        MicrosoftGraphDefaultBaseUrlLbl: Label 'https://graph.microsoft.com/%1', Comment = '%1 = Graph API Version', Locked = true;        RangeHeaderLbl: Label 'bytes=%1-%2', Locked = true;        UntrustedUploadHostErr: Label 'Upload URL points to an untrusted host.', Locked = true;        AllowedUploadUrlPatternLbl: Label '^https:\/\/[a-zA-Z0-9][a-zA-Z0-9\.\-]*\.(sharepoint\.com|microsoft\.com|microsoftonline\.com)(\/.*)?$', Locked = true;    /// <summary>    /// Initializes the Graph Request Helper with an authorization.    /// </summary>    /// <param name="GraphAuthorization">The Graph API authorization to use.</param>    procedure Initialize(GraphAuthorization: Interface "Graph Authorization")    begin        ApiVersion := Enum::"Graph API Version"::"v1.0";        CustomBaseUrl := '';        GraphClient.Initialize(ApiVersion, GraphAuthorization);    end;    /// <summary>    /// Initializes the Graph Request Helper with a specific API version and authorization.    /// </summary>    /// <param name="NewApiVersion">The Graph API version to use.</param>    /// <param name="GraphAuthorization">The Graph API authorization to use.</param>    procedure Initialize(NewApiVersion: Enum "Graph API Version"; GraphAuthorization: Interface "Graph Authorization")    begin        ApiVersion := NewApiVersion;        CustomBaseUrl := '';        GraphClient.Initialize(NewApiVersion, GraphAuthorization);    end;    /// <summary>    /// Initializes the Graph Request Helper with a custom base URL and authorization.    /// </summary>    /// <param name="NewBaseUrl">The custom base URL to use.</param>    /// <param name="GraphAuthorization">The Graph API authorization to use.</param>    procedure Initialize(NewBaseUrl: Text; GraphAuthorization: Interface "Graph Authorization")    begin        ApiVersion := Enum::"Graph API Version"::"v1.0";        CustomBaseUrl := NewBaseUrl;        GraphClient.Initialize(ApiVersion, GraphAuthorization);    end;    /// <summary>    /// Initializes the Graph Request Helper with an HTTP client handler for testing.    /// </summary>    /// <param name="NewApiVersion">The Graph API version to use.</param>    /// <param name="GraphAuthorization">The Graph API authorization to use.</param>    /// <param name="HttpClientHandler">HTTP client handler for intercepting requests.</param>    procedure Initialize(NewApiVersion: Enum "Graph API Version"; GraphAuthorization: Interface "Graph Authorization"; HttpClientHandler: Interface "Http Client Handler")    begin        ApiVersion := NewApiVersion;        CustomBaseUrl := '';        GraphClient.Initialize(NewApiVersion, GraphAuthorization, HttpClientHandler);    end;    /// <summary>    /// Gets the base URL for Graph API calls.    /// </summary>    /// <returns>The base URL for Graph API requests.</returns>    procedure GetGraphApiBaseUrl(): Text    begin        if CustomBaseUrl <> '' then            exit(CustomBaseUrl);        exit(StrSubstNo(MicrosoftGraphDefaultBaseUrlLbl, ApiVersion));    end;    #region GET Requests    /// <summary>    /// Makes a GET request to the Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Get(Endpoint: Text; var ResponseJson: JsonObject; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        FinalEndpoint: Text;    begin        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Get(FinalEndpoint, GraphOptionalParameters, HttpResponseMessage);        exit(ProcessJsonResponse(HttpResponseMessage, ResponseJson));    end;    /// <summary>    /// Makes a GET request to the Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Get(Endpoint: Text; var ResponseJson: JsonObject): Boolean    var        GraphOptionalParameters: Codeunit "Graph Optional Parameters";    begin        exit(Get(Endpoint, ResponseJson, GraphOptionalParameters));    end;    /// <summary>    /// Downloads a file from Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="TempBlob">The blob to write the file content to.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure DownloadFile(Endpoint: Text; var TempBlob: Codeunit "Temp Blob"): Boolean    var        GraphOptionalParameters: Codeunit "Graph Optional Parameters";    begin        exit(DownloadFile(Endpoint, TempBlob, GraphOptionalParameters));    end;    /// <summary>    /// Downloads a file from Microsoft Graph API with optional parameters.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="TempBlob">The blob to write the file content to.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure DownloadFile(Endpoint: Text; var TempBlob: Codeunit "Temp Blob"; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        FinalEndpoint: Text;    begin        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Get(FinalEndpoint, GraphOptionalParameters, HttpResponseMessage);        exit(ProcessStreamResponse(HttpResponseMessage, TempBlob));    end;    /// <summary>    /// Downloads a chunk of a file using HTTP Range header.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="RangeStart">Starting byte position (0-based, inclusive).</param>    /// <param name="RangeEnd">Ending byte position (0-based, inclusive).</param>    /// <param name="TempBlob">The blob to receive the chunk content.</param>    /// <returns>True if the chunk was downloaded successfully; otherwise false.</returns>    procedure DownloadChunk(Endpoint: Text; RangeStart: BigInteger; RangeEnd: BigInteger; var TempBlob: Codeunit "Temp Blob"): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        GraphOptionalParameters: Codeunit "Graph Optional Parameters";        FinalEndpoint: Text;        RangeHeader: Text;    begin        // Set Range header: "bytes=0-104857599"        RangeHeader := StrSubstNo(RangeHeaderLbl, RangeStart, RangeEnd);        GraphOptionalParameters.SetRequestHeader(Enum::"Graph Request Header"::Range, RangeHeader);        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Get(FinalEndpoint, GraphOptionalParameters, HttpResponseMessage);        // Graph API should return 206 Partial Content for Range requests        // But we'll accept both 200 (full content) and 206 (partial content)        SharePointDiagnostics.SetParameters(HttpResponseMessage.GetIsSuccessStatusCode(),            HttpResponseMessage.GetHttpStatusCode(), HttpResponseMessage.GetReasonPhrase(),            TryGetRetryAfterHeaderValue(HttpResponseMessage), HttpResponseMessage.GetErrorMessage());        if not HttpResponseMessage.GetIsSuccessStatusCode() then            exit(false);        exit(ProcessStreamResponse(HttpResponseMessage, TempBlob));    end;    #endregion    #region POST Requests    /// <summary>    /// Makes a POST request to the Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="RequestBody">The request body.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Post(Endpoint: Text; RequestBody: JsonObject; var ResponseJson: JsonObject): Boolean    var        GraphOptionalParameters: Codeunit "Graph Optional Parameters";    begin        exit(Post(Endpoint, RequestBody, GraphOptionalParameters, ResponseJson));    end;    /// <summary>    /// Makes a POST request to the Microsoft Graph API with optional parameters.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="RequestBody">The request body.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Post(Endpoint: Text; RequestBody: JsonObject; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; var ResponseJson: JsonObject): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        HttpContent: Codeunit "Http Content";        FinalEndpoint: Text;    begin        HttpContent.Create(RequestBody);        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Post(FinalEndpoint, GraphOptionalParameters, HttpContent, HttpResponseMessage);        exit(ProcessJsonResponse(HttpResponseMessage, ResponseJson));    end;    #endregion    #region File Upload    /// <summary>    /// Uploads a file to Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="FileInStream">The stream containing the file content.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure UploadFile(Endpoint: Text; FileInStream: InStream; var ResponseJson: JsonObject): Boolean    var        GraphOptionalParameters: Codeunit "Graph Optional Parameters";    begin        exit(UploadFile(Endpoint, FileInStream, GraphOptionalParameters, ResponseJson));    end;    /// <summary>    /// Uploads a file to Microsoft Graph API with optional parameters.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="FileInStream">The stream containing the file content.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure UploadFile(Endpoint: Text; FileInStream: InStream; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; var ResponseJson: JsonObject): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        HttpContent: Codeunit "Http Content";        FinalEndpoint: Text;    begin        HttpContent.Create(FileInStream);        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Put(FinalEndpoint, GraphOptionalParameters, HttpContent, HttpResponseMessage);        exit(ProcessJsonResponse(HttpResponseMessage, ResponseJson));    end;    #endregion    #region Chunked File Upload    /// <summary>    /// Creates an upload session for chunked file upload.    /// </summary>    /// <param name="Endpoint">The endpoint to create the upload session.</param>    /// <param name="FileName">Name of the file to upload.</param>    /// <param name="FileSize">Size of the file in bytes.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <param name="GraphConflictBehavior">How to handle conflicts if a file with the same name exists.</param>    /// <param name="UploadUrlResult">The upload URL result for the session.</param>    /// <returns>True if the upload session was created successfully; otherwise false.</returns>    procedure CreateUploadSession(Endpoint: Text; FileName: Text; FileSize: Integer; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; GraphConflictBehavior: Enum "Graph ConflictBehavior"; var UploadUrlResult: Text): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        HttpContent: Codeunit "Http Content";        RequestBodyJson: JsonObject;        ItemJson: JsonObject;        ResponseJson: JsonObject;        JsonToken: JsonToken;        FinalEndpoint: Text;    begin        // Create request body for upload session        ItemJson.Add('@microsoft.graph.conflictBehavior', Format(GraphConflictBehavior));        ItemJson.Add('name', FileName);        // Can also add description or fileSystemInfo here if needed        RequestBodyJson.Add('item', ItemJson);        HttpContent.Create(RequestBodyJson);        FinalEndpoint := PrepareEndpoint(Endpoint + ':/createUploadSession', GraphOptionalParameters);        GraphClient.Post(FinalEndpoint, GraphOptionalParameters, HttpContent, HttpResponseMessage);        if not ProcessJsonResponse(HttpResponseMessage, ResponseJson) then            exit(false);        // Extract uploadUrl from the response        if ResponseJson.Get('uploadUrl', JsonToken) then            UploadUrlResult := JsonToken.AsValue().AsText()        else            exit(false);        exit(true);    end;    /// <summary>    /// Uploads a chunk of file content to an upload session.    /// </summary>    /// <param name="UploadUrl">The upload URL for the session.</param>    /// <param name="ChunkContent">The content of the chunk.</param>    /// <param name="ContentRange">The content range header value (e.g., "bytes 0-1023/5000").</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <remarks>Uses a separate RestClient instead of GraphClient because the upload URL is a complete URL and must not include the Authorization header.</remarks>    /// <returns>True if the chunk was uploaded successfully; otherwise false.</returns>    procedure UploadChunk(UploadUrl: Text; var ChunkContent: InStream; ContentRange: Text; var ResponseJson: JsonObject): Boolean    var        RestClient: Codeunit "Rest Client";        HttpContent: Codeunit "Http Content";        HttpResponseMessage: Codeunit "Http Response Message";    begin        Clear(ResponseJson);        // Validate that the upload URL points to a trusted Microsoft host        if not IsAllowedUploadUrl(UploadUrl) then begin            SharePointDiagnostics.SetParameters(false, 0, UntrustedUploadHostErr, 0, '');            exit(false);        end;        // Initialize a fresh RestClient without passing any authorization        RestClient.Initialize();        // Create the HTTP content with our chunk        HttpContent.Create(ChunkContent);        HttpContent.SetHeader('Content-Range', ContentRange);        HttpContent.SetContentTypeHeader('application/octet-stream');        // Use direct PUT method on the upload URL        // The UploadUrl is already a complete URL from the upload session        HttpResponseMessage := RestClient.Put(UploadUrl, HttpContent);        SharePointDiagnostics.SetParameters(HttpResponseMessage.GetIsSuccessStatusCode(),            HttpResponseMessage.GetHttpStatusCode(), HttpResponseMessage.GetReasonPhrase(),            TryGetRetryAfterHeaderValue(HttpResponseMessage), HttpResponseMessage.GetErrorMessage());        if not HttpResponseMessage.GetIsSuccessStatusCode() then            exit(false);        ResponseJson := HttpResponseMessage.GetContent().AsJsonObject();        exit(true);    end;    #endregion    #region PUT Requests    /// <summary>    /// Makes a PUT request to the Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="RequestBody">The request body.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Put(Endpoint: Text; RequestBody: JsonObject; var ResponseJson: JsonObject): Boolean    var        GraphOptionalParameters: Codeunit "Graph Optional Parameters";    begin        exit(Put(Endpoint, RequestBody, GraphOptionalParameters, ResponseJson));    end;    /// <summary>    /// Makes a PUT request to the Microsoft Graph API with optional parameters.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="RequestBody">The request body.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Put(Endpoint: Text; RequestBody: JsonObject; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; var ResponseJson: JsonObject): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        HttpContent: Codeunit "Http Content";        FinalEndpoint: Text;    begin        HttpContent.Create(RequestBody);        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Put(FinalEndpoint, GraphOptionalParameters, HttpContent, HttpResponseMessage);        exit(ProcessJsonResponse(HttpResponseMessage, ResponseJson));    end;    /// <summary>    /// Makes a PUT request with binary content and custom headers to the Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="Content">The binary content stream.</param>    /// <param name="ContentType">The content type of the binary data.</param>    /// <param name="AdditionalHeaders">Dictionary of additional headers to include.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure PutContent(Endpoint: Text; Content: InStream; ContentType: Text; var AdditionalHeaders: Dictionary of [Text, Text]; var ResponseJson: JsonObject): Boolean    var        GraphOptionalParameters: Codeunit "Graph Optional Parameters";    begin        exit(PutContent(Endpoint, Content, ContentType, AdditionalHeaders, GraphOptionalParameters, false, ResponseJson));    end;    /// <summary>    /// Makes a PUT request with binary content and custom headers to the Microsoft Graph API with optional parameters.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="Content">The binary content stream.</param>    /// <param name="ContentType">The content type of the binary data.</param>    /// <param name="AdditionalHeaders">Dictionary of additional headers to include.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <param name="IsCompleteUrl">If true, the endpoint is treated as a complete URL and not processed further.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure PutContent(Endpoint: Text; Content: InStream; ContentType: Text; var AdditionalHeaders: Dictionary of [Text, Text]; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; IsCompleteUrl: Boolean; var ResponseJson: JsonObject): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        HttpContent: Codeunit "Http Content";        FinalEndpoint: Text;        HeaderKey: Text;    begin        HttpContent.Create(Content);        HttpContent.SetContentTypeHeader(ContentType);        // Add any additional headers        foreach HeaderKey in AdditionalHeaders.Keys() do            HttpContent.SetHeader(HeaderKey, AdditionalHeaders.Get(HeaderKey));        if IsCompleteUrl then            FinalEndpoint := Endpoint        else            FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Put(FinalEndpoint, GraphOptionalParameters, HttpContent, HttpResponseMessage);        exit(ProcessJsonResponse(HttpResponseMessage, ResponseJson));    end;    #endregion    #region PATCH Requests    /// <summary>    /// Makes a PATCH request to the Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="RequestBody">The request body.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Patch(Endpoint: Text; RequestBody: JsonObject; var ResponseJson: JsonObject): Boolean    var        GraphOptionalParameters: Codeunit "Graph Optional Parameters";    begin        exit(Patch(Endpoint, RequestBody, GraphOptionalParameters, ResponseJson));    end;    /// <summary>    /// Makes a PATCH request to the Microsoft Graph API with optional parameters.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="RequestBody">The request body.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <param name="ResponseJson">The JSON response.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Patch(Endpoint: Text; RequestBody: JsonObject; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; var ResponseJson: JsonObject): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        HttpContent: Codeunit "Http Content";        FinalEndpoint: Text;    begin        HttpContent.Create(RequestBody);        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Patch(FinalEndpoint, GraphOptionalParameters, HttpContent, HttpResponseMessage);        exit(ProcessJsonResponse(HttpResponseMessage, ResponseJson));    end;    #endregion    #region DELETE Requests    /// <summary>    /// Makes a DELETE request to the Microsoft Graph API.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Delete(Endpoint: Text): Boolean    var        GraphOptionalParameters: Codeunit "Graph Optional Parameters";    begin        exit(Delete(Endpoint, GraphOptionalParameters));    end;    /// <summary>    /// Makes a DELETE request to the Microsoft Graph API with optional parameters.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure Delete(Endpoint: Text; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        FinalEndpoint: Text;    begin        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        GraphClient.Delete(FinalEndpoint, GraphOptionalParameters, HttpResponseMessage);        exit(ProcessResponse(HttpResponseMessage));    end;    #endregion    #region Pagination    /// <summary>    /// Makes a GET request to the Microsoft Graph API with pagination support and returns all pages automatically.    /// </summary>    /// <param name="Endpoint">The endpoint to request.</param>    /// <param name="GraphOptionalParameters">Optional parameters for the request.</param>    /// <param name="JsonArray">The JSON array containing all results from all pages.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    procedure GetAllPages(Endpoint: Text; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; var JsonArray: JsonArray): Boolean    var        HttpResponseMessage: Codeunit "Http Response Message";        FinalEndpoint: Text;    begin        FinalEndpoint := PrepareEndpoint(Endpoint, GraphOptionalParameters);        if not GraphClient.GetAllPages(FinalEndpoint, GraphOptionalParameters, HttpResponseMessage, JsonArray) then begin            SharePointDiagnostics.SetParameters(HttpResponseMessage.GetIsSuccessStatusCode(),                HttpResponseMessage.GetHttpStatusCode(), HttpResponseMessage.GetReasonPhrase(),                TryGetRetryAfterHeaderValue(HttpResponseMessage), HttpResponseMessage.GetErrorMessage());            exit(false);        end;        SharePointDiagnostics.SetParameters(HttpResponseMessage.GetIsSuccessStatusCode(),            HttpResponseMessage.GetHttpStatusCode(), HttpResponseMessage.GetReasonPhrase(),            TryGetRetryAfterHeaderValue(HttpResponseMessage), HttpResponseMessage.GetErrorMessage());        exit(true);    end;    #endregion    #region Helpers    /// <summary>    /// Configures conflict behavior in optional parameters    /// </summary>    /// <param name="GraphOptionalParameters">Optional parameters to configure</param>    /// <param name="ConflictBehavior">The desired conflict behavior</param>    procedure ConfigureConflictBehavior(var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; ConflictBehavior: Enum "Graph ConflictBehavior")    begin        GraphOptionalParameters.SetMicrosftGraphConflictBehavior(ConflictBehavior);    end;    /// <summary>    /// Returns detailed information on last API call.    /// </summary>    /// <returns>Codeunit holding http response status, reason phrase, headers and possible error information for the last API call</returns>    procedure GetDiagnostics(): Interface "HTTP Diagnostics"    begin        exit(SharePointDiagnostics);    end;    /// <summary>    /// Prepares the endpoint for a request by adding optional parameters.    /// </summary>    /// <param name="Endpoint">The base endpoint.</param>    /// <param name="GraphOptionalParameters">Optional parameters to add to the endpoint.</param>    /// <returns>The final endpoint with optional parameters.</returns>    local procedure PrepareEndpoint(Endpoint: Text; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Text    var        SharePointGraphUriBuilder: Codeunit "Sharepoint Graph Uri Builder";    begin        exit(SharePointGraphUriBuilder.AddOptionalParametersToEndpoint(Endpoint, GraphOptionalParameters));    end;    /// <summary>    /// Common response processing - sets diagnostics and checks for success status    /// </summary>    /// <param name="HttpResponseMessage">The HTTP response message to process</param>    /// <returns>True if the response is successful; otherwise false</returns>    local procedure ProcessResponse(HttpResponseMessage: Codeunit "Http Response Message"): Boolean    begin        SharePointDiagnostics.SetParameters(HttpResponseMessage.GetIsSuccessStatusCode(),            HttpResponseMessage.GetHttpStatusCode(), HttpResponseMessage.GetReasonPhrase(),            TryGetRetryAfterHeaderValue(HttpResponseMessage), HttpResponseMessage.GetErrorMessage());        exit(HttpResponseMessage.GetIsSuccessStatusCode());    end;    /// <summary>    /// Processes an HTTP response and extracts the JSON content.    /// </summary>    /// <param name="HttpResponseMessage">The HTTP response message.</param>    /// <param name="ResponseJson">The JSON response to populate.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    local procedure ProcessJsonResponse(HttpResponseMessage: Codeunit "Http Response Message"; var ResponseJson: JsonObject): Boolean    begin        if not ProcessResponse(HttpResponseMessage) then            exit(false);        ResponseJson := HttpResponseMessage.GetContent().AsJsonObject();        exit(true);    end;    /// <summary>    /// Processes an HTTP response and extracts the stream content.    /// </summary>    /// <param name="HttpResponseMessage">The HTTP response message.</param>    /// <param name="TempBlob">The blob to populate with the response content.</param>    /// <returns>True if the request was successful; otherwise false.</returns>    local procedure ProcessStreamResponse(HttpResponseMessage: Codeunit "Http Response Message"; var TempBlob: Codeunit "Temp Blob"): Boolean    begin        if not ProcessResponse(HttpResponseMessage) then            exit(false);        TempBlob := HttpResponseMessage.GetContent().AsBlob();        exit(true);    end;    local procedure IsAllowedUploadUrl(Url: Text): Boolean    var        Uri: Codeunit Uri;    begin        exit(Uri.IsValidURIPattern(Url, AllowedUploadUrlPatternLbl));    end;    local procedure TryGetRetryAfterHeaderValue(HttpResponseMessage: Codeunit "Http Response Message") RetryAfterAsInteger: Integer    var        Values: array[1] of Text;    begin        if not HttpResponseMessage.GetHeaders().GetValues('Retry-After', Values) then            exit;        //Since the HTTP Diagnostics interface expects an integer in Retry-After, we must convert the header to a number.        //At the same time, the HTTP specification states that there may be a date there.        if not Evaluate(RetryAfterAsInteger, Values[1]) then            exit(0);    end;    #endregion}