Codeunit 9120 SharePoint Graph Client Impl.
src/System Application/App/SharePoint/src/graph/SharePointGraphClientImpl.Codeunit.al2,416 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 interacting with SharePoint through Microsoft Graph API./// This implementation uses native Graph API concepts and models./// </summary>codeunit 9120 "SharePoint Graph Client Impl."{ Access = Internal; InherentEntitlements = X; InherentPermissions = X; var SharePointGraphRequestHelper: Codeunit "SharePoint Graph Req. Helper"; SharePointGraphParser: Codeunit "Sharepoint Graph Parser"; SharePointGraphUriBuilder: Codeunit "Sharepoint Graph Uri Builder"; SiteId: Text; SharePointUrl: Text; DefaultDriveId: Text; IsInitialized: Boolean; NotInitializedErr: Label 'SharePoint Graph Client is not initialized. Call Initialize first.'; InvalidSharePointUrlErr: Label 'Invalid SharePoint URL ''%1''.', Comment = '%1 = URL string'; SharePointUrlPatternLbl: Label '^https:\/\/[a-zA-Z0-9][a-zA-Z0-9\-]*\.sharepoint\.com(\/.*)?$', Locked = true; RetrieveSiteInfoErr: Label 'Failed to retrieve SharePoint site information from Graph API. %1', Comment = '%1 = Error message'; ContentRangeHeaderLbl: Label 'bytes %1-%2/%3', Locked = true, Comment = '%1 = Start Bytes, %2 = End Bytes, %3 = Total Bytes'; FailedToRetrieveListsErr: Label 'Failed to retrieve lists: %1', Comment = '%1 = Error message'; FailedToParseListsErr: Label 'Failed to parse lists collection from response'; FailedToRetrieveListErr: Label 'Failed to retrieve list: %1', Comment = '%1 = Error message'; FailedToParseListErr: Label 'Failed to parse list details from response'; InvalidListIdErr: Label 'List ID cannot be empty'; InvalidDisplayNameErr: Label 'Display name cannot be empty'; FailedToCreateListErr: Label 'Failed to create list: %1', Comment = '%1 = Error message'; FailedToParseCreatedListErr: Label 'Failed to parse created list details from response'; FailedToRetrieveListItemsErr: Label 'Failed to retrieve list items: %1', Comment = '%1 = Error message'; FailedToParseListItemsErr: Label 'Failed to parse list items collection from response'; FailedToCreateListItemErr: Label 'Failed to create list item: %1', Comment = '%1 = Error message'; FailedToParseCreatedListItemErr: Label 'Failed to parse created list item details from response'; NoDefaultDriveIdErr: Label 'Default drive ID is not available. Please check the SharePoint site.'; FailedToRetrieveDefaultDriveErr: Label 'Failed to retrieve default drive: %1', Comment = '%1 = Error message'; FailedToRetrieveDrivesErr: Label 'Failed to retrieve drives: %1', Comment = '%1 = Error message'; FailedToParseDrivesErr: Label 'Failed to parse drives collection from response'; FailedToRetrieveDriveErr: Label 'Failed to retrieve drive: %1', Comment = '%1 = Error message'; FailedToParseDriveErr: Label 'Failed to parse drive details from response'; InvalidDriveIdErr: Label 'Drive ID cannot be empty'; FailedToRetrieveRootItemsErr: Label 'Failed to retrieve root items: %1', Comment = '%1 = Error message'; FailedToParseRootItemsErr: Label 'Failed to parse root items collection from response'; InvalidFolderIdErr: Label 'Folder ID cannot be empty'; FailedToRetrieveFolderItemsErr: Label 'Failed to retrieve folder items: %1', Comment = '%1 = Error message'; FailedToParseFolderItemsErr: Label 'Failed to parse folder items collection from response'; FailedToRetrieveItemsByPathErr: Label 'Failed to retrieve items by path: %1', Comment = '%1 = Error message'; FailedToParseItemsByPathErr: Label 'Failed to parse items collection from response'; InvalidItemIdErr: Label 'Item ID cannot be empty'; FailedToRetrieveDriveItemErr: Label 'Failed to retrieve drive item: %1', Comment = '%1 = Error message'; FailedToParseDriveItemErr: Label 'Failed to parse drive item details from response'; InvalidItemPathErr: Label 'Item path cannot be empty'; FailedToRetrieveDriveItemByPathErr: Label 'Failed to retrieve drive item by path: %1', Comment = '%1 = Error message'; FailedToParseDriveItemByPathErr: Label 'Failed to parse drive item details from response'; InvalidFolderNameErr: Label 'Folder name cannot be empty'; FailedToCreateFolderErr: Label 'Failed to create folder: %1', Comment = '%1 = Error message'; FailedToParseCreatedFolderErr: Label 'Failed to parse created folder details from response'; InvalidFileNameErr: Label 'File name cannot be empty'; FailedToUploadFileErr: Label 'Failed to upload file: %1', Comment = '%1 = Error message'; FailedToParseUploadedFileErr: Label 'Failed to parse uploaded file details from response'; InvalidFileSizeErr: Label 'File size must be greater than 0'; FailedToCreateUploadSessionErr: Label 'Failed to create upload session: %1', Comment = '%1 = Error message'; FailedToUploadChunkErr: Label 'Failed to upload file chunk: %1', Comment = '%1 = Error message'; NoUploadResponseErr: Label 'No response received from chunked upload'; FailedToParseChunkedUploadErr: Label 'Failed to parse chunked upload response'; FailedToDownloadFileErr: Label 'Failed to download file: %1', Comment = '%1 = Error message'; InvalidFilePathErr: Label 'File path cannot be empty'; FailedToDownloadFileByPathErr: Label 'Failed to download file by path: %1', Comment = '%1 = Error message'; FailedToDownloadChunkErr: Label 'Failed to download file chunk %1-%2: %3', Comment = '%1 = Start byte, %2 = End byte, %3 = Error message'; FailedToGetFileSizeErr: Label 'Failed to get file size for chunked download: %1', Comment = '%1 = Error message'; FailedToDeleteItemErr: Label 'Failed to delete item: %1', Comment = '%1 = Error message'; FailedToDeleteItemByPathErr: Label 'Failed to delete item by path: %1', Comment = '%1 = Error message'; InvalidTargetPathErr: Label 'Target path cannot be empty'; FailedToCopyItemErr: Label 'Failed to copy item: %1', Comment = '%1 = Error message'; FailedToMoveItemErr: Label 'Failed to move item: %1', Comment = '%1 = Error message'; InvalidUpdateBodyErr: Label 'Update properties cannot be empty'; FailedToUpdateDriveItemErr: Label 'Failed to update drive item: %1', Comment = '%1 = Error message'; FailedToParseUpdatedDriveItemErr: Label 'Failed to parse updated drive item details from response'; InvalidNewNameErr: Label 'New name cannot be empty'; InvalidFieldsErr: Label 'Fields JSON object cannot be empty'; ItemBufferCollisionErr: Label 'The record already contains item %1 from a different list. Use a separate record variable per list.', Comment = '%1 = Item ID'; ItemBufferCollisionTelemetryErr: Label 'The record already contains item from a different list. Use a separate record variable per list.', Locked = true; FailedToRetrieveListItemErr: Label 'Failed to retrieve list item: %1', Comment = '%1 = Error message'; FailedToParseListItemErr: Label 'Failed to parse list item details from response'; FailedToUpdateListItemErr: Label 'Failed to update list item: %1', Comment = '%1 = Error message'; FailedToParseUpdatedListItemErr: Label 'Failed to parse updated list item fields from response'; GraphSharePointCategoryLbl: Label 'AL Graph SharePoint', Locked = true; OperationSuccessTelemetryMsg: Label '%1 completed successfully.', Locked = true, Comment = '%1 = Operation name'; #region Initialization /// <summary> /// Initializes SharePoint Graph client. /// </summary> /// <param name="NewSharePointUrl">SharePoint site URL.</param> /// <param name="GraphAuthorization">The Graph API authorization to use.</param> procedure Initialize(NewSharePointUrl: Text; GraphAuthorization: Interface "Graph Authorization") begin SharePointGraphRequestHelper.Initialize(GraphAuthorization); InitializeCommon(NewSharePointUrl); end; /// <summary> /// Initializes SharePoint Graph client with a specific API version. /// </summary> /// <param name="NewSharePointUrl">SharePoint site URL.</param> /// <param name="ApiVersion">The Graph API version to use.</param> /// <param name="GraphAuthorization">The Graph API authorization to use.</param> procedure Initialize(NewSharePointUrl: Text; ApiVersion: Enum "Graph API Version"; GraphAuthorization: Interface "Graph Authorization") begin SharePointGraphRequestHelper.Initialize(ApiVersion, GraphAuthorization); InitializeCommon(NewSharePointUrl); end; /// <summary> /// Initializes SharePoint Graph client with a custom base URL. /// </summary> /// <param name="NewSharePointUrl">SharePoint site URL.</param> /// <param name="BaseUrl">The custom base URL for Graph API.</param> /// <param name="GraphAuthorization">The Graph API authorization to use.</param> procedure Initialize(NewSharePointUrl: Text; BaseUrl: Text; GraphAuthorization: Interface "Graph Authorization") begin SharePointGraphRequestHelper.Initialize(BaseUrl, GraphAuthorization); InitializeCommon(NewSharePointUrl); end; /// <summary> /// Initializes SharePoint Graph client with an HTTP client handler for testing. /// </summary> /// <param name="NewSharePointUrl">SharePoint site URL.</param> /// <param name="ApiVersion">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(NewSharePointUrl: Text; ApiVersion: Enum "Graph API Version"; GraphAuthorization: Interface "Graph Authorization"; HttpClientHandler: Interface "Http Client Handler") begin SharePointGraphRequestHelper.Initialize(ApiVersion, GraphAuthorization, HttpClientHandler); InitializeCommon(NewSharePointUrl); end; /// <summary> /// Common initialization logic shared by all Initialize overloads. /// </summary> /// <param name="NewSharePointUrl">SharePoint site URL.</param> local procedure InitializeCommon(NewSharePointUrl: Text) var Uri: Codeunit Uri; begin // Validate that the URL points to a SharePoint domain to prevent sending credentials to external URLs if not Uri.IsValidURIPattern(NewSharePointUrl, SharePointUrlPatternLbl) then begin Session.LogMessage('0000RNN', StrSubstNo(InvalidSharePointUrlErr, NewSharePointUrl), Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); Error(InvalidSharePointUrlErr, NewSharePointUrl); end; // If we have a new URL, clear the cached IDs so they'll be re-acquired if SharePointUrl <> NewSharePointUrl then begin SharePointUrl := NewSharePointUrl; SiteId := ''; DefaultDriveId := ''; end; IsInitialized := true; end; local procedure GetSiteIdFromUrl(Url: Text) var JsonResponse: JsonObject; JsonToken: JsonToken; HostName: Text; RelativePath: Text; Endpoint: Text; begin // Extract hostname and relative path from the URL HostName := ExtractHostName(Url); RelativePath := ExtractRelativePath(Url); if (HostName = '') or (RelativePath = '') then begin Session.LogMessage('0000RK6', StrSubstNo(InvalidSharePointUrlErr, Url), Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); Error(InvalidSharePointUrlErr, Url); end; // Build the Graph endpoint to get site information Endpoint := SharePointGraphUriBuilder.GetSiteByHostAndPathEndpoint(HostName, RelativePath); if not SharePointGraphRequestHelper.Get(Endpoint, JsonResponse) then begin Session.LogMessage('0000RK7', StrSubstNo(RetrieveSiteInfoErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()), Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); Error(RetrieveSiteInfoErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); end; if JsonResponse.Get('id', JsonToken) then SiteId := JsonToken.AsValue().AsText(); end; local procedure GetDefaultDriveId() var JsonResponse: JsonObject; JsonToken: JsonToken; begin if SiteId = '' then exit; if not SharePointGraphRequestHelper.Get(SharePointGraphUriBuilder.GetDriveEndpoint(), JsonResponse) then exit; if JsonResponse.Get('id', JsonToken) then DefaultDriveId := JsonToken.AsValue().AsText(); end; local procedure ExtractHostName(Url: Text): Text var UriBuilder: Codeunit "Uri Builder"; begin UriBuilder.Init(Url); exit(UriBuilder.GetHost()); // e.g. contoso.sharepoint.com end; local procedure ExtractRelativePath(Url: Text): Text var UriBuilder: Codeunit "Uri Builder"; Path: Text; begin UriBuilder.Init(Url); // Azure AD / Graph requires the path to start with '/' Path := UriBuilder.GetPath(); // Guarantee at least '/' if Path = '' then Path := '/'; exit(Path); end; local procedure EnsureInitialized() begin if not IsInitialized then begin Session.LogMessage('0000RK8', NotInitializedErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); Error(NotInitializedErr); end; end; #endregion #region Lists /// <summary> /// Gets all lists from the SharePoint site. /// </summary> /// <param name="GraphLists">Collection of the result (temporary record).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetLists(var GraphLists: Record "SharePoint Graph List" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetLists(GraphLists, GraphOptionalParameters)); end; /// <summary> /// Gets all lists from the SharePoint site. /// </summary> /// <param name="GraphLists">Collection of the result (temporary record).</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetLists(var GraphLists: Record "SharePoint Graph List" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonArray: JsonArray; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Use Graph pagination to get all pages automatically if not SharePointGraphRequestHelper.GetAllPages(SharePointGraphUriBuilder.GetListsEndpoint(), GraphOptionalParameters, JsonArray) then begin ErrorMessage := StrSubstNo(FailedToRetrieveListsErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RK9', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Parse the combined results from all pages if not SharePointGraphParser.ParseListCollection(JsonArray, GraphLists) then begin SharePointGraphResponse.SetError(FailedToParseListsErr); Session.LogMessage('0000RKA', FailedToParseListsErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RKB', StrSubstNo(OperationSuccessTelemetryMsg, 'GetLists'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets a SharePoint list by ID. /// </summary> /// <param name="ListId">ID of the list to retrieve.</param> /// <param name="GraphList">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetList(ListId: Text; var GraphList: Record "SharePoint Graph List" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetList(ListId, GraphList, GraphOptionalParameters)); end; /// <summary> /// Gets a SharePoint list by ID. /// </summary> /// <param name="ListId">ID of the list to retrieve.</param> /// <param name="GraphList">Record to store the result.</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetList(ListId: Text; var GraphList: Record "SharePoint Graph List" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ListId = '' then begin SharePointGraphResponse.SetError(InvalidListIdErr); Session.LogMessage('0000RKC', InvalidListIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Make the API request if not SharePointGraphRequestHelper.Get(SharePointGraphUriBuilder.GetListEndpoint(ListId), JsonResponse, GraphOptionalParameters) then begin ErrorMessage := StrSubstNo(FailedToRetrieveListErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RKD', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphList.Init(); if not SharePointGraphParser.ParseListItem(JsonResponse, GraphList) then begin SharePointGraphResponse.SetError(FailedToParseListErr); Session.LogMessage('0000RKE', FailedToParseListErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphList.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RKF', StrSubstNo(OperationSuccessTelemetryMsg, 'GetList'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Creates a new SharePoint list. /// </summary> /// <param name="DisplayName">Display name for the list.</param> /// <param name="Description">Description for the list.</param> /// <param name="GraphList">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure CreateList(DisplayName: Text; Description: Text; var GraphList: Record "SharePoint Graph List" temporary): Codeunit "SharePoint Graph Response" begin exit(CreateList(DisplayName, 'genericList', Description, GraphList)); end; /// <summary> /// Creates a new SharePoint list. /// </summary> /// <param name="DisplayName">Display name for the list.</param> /// <param name="ListTemplate">Template for the list (genericList, documentLibrary, etc.)</param> /// <param name="Description">Description for the list.</param> /// <param name="GraphList">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure CreateList(DisplayName: Text; ListTemplate: Text; Description: Text; var GraphList: Record "SharePoint Graph List" temporary): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; RequestJsonObj: JsonObject; ListJsonObj: JsonObject; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if DisplayName = '' then begin SharePointGraphResponse.SetError(InvalidDisplayNameErr); Session.LogMessage('0000RKG', InvalidDisplayNameErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Create the request body with list properties RequestJsonObj.Add('displayName', DisplayName); RequestJsonObj.Add('description', Description); // Add list template ListJsonObj.Add('template', ListTemplate); RequestJsonObj.Add('list', ListJsonObj); // Post the request to create the list if not SharePointGraphRequestHelper.Post(SharePointGraphUriBuilder.GetListsEndpoint(), RequestJsonObj, JsonResponse) then begin ErrorMessage := StrSubstNo(FailedToCreateListErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RKH', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphList.Init(); if not SharePointGraphParser.ParseListItem(JsonResponse, GraphList) then begin SharePointGraphResponse.SetError(FailedToParseCreatedListErr); Session.LogMessage('0000RKI', FailedToParseCreatedListErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphList.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RKJ', StrSubstNo(OperationSuccessTelemetryMsg, 'CreateList'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; #endregion #region List Items /// <summary> /// Gets items from a SharePoint list. /// </summary> /// <param name="ListId">ID of the list.</param> /// <param name="GraphListItems">Collection of the result (temporary record).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetListItems(ListId: Text; var GraphListItems: Record "SharePoint Graph List Item" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetListItems(ListId, GraphListItems, GraphOptionalParameters)); end; /// <summary> /// Gets items from a SharePoint list. /// </summary> /// <param name="ListId">ID of the list.</param> /// <param name="GraphListItems">Collection of the result (temporary record).</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetListItems(ListId: Text; var GraphListItems: Record "SharePoint Graph List Item" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonArray: JsonArray; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ListId = '' then begin SharePointGraphResponse.SetError(InvalidListIdErr); Session.LogMessage('0000RKK', InvalidListIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Use Graph pagination to get all pages automatically if not SharePointGraphRequestHelper.GetAllPages(SharePointGraphUriBuilder.GetListItemsEndpoint(ListId), GraphOptionalParameters, JsonArray) then begin ErrorMessage := StrSubstNo(FailedToRetrieveListItemsErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RKL', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Parse the combined results from all pages if not SharePointGraphParser.ParseListItemCollection(JsonArray, ListId, GraphListItems) then begin SharePointGraphResponse.SetError(FailedToParseListItemsErr); Session.LogMessage('0000RKM', FailedToParseListItemsErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RKN', StrSubstNo(OperationSuccessTelemetryMsg, 'GetListItems'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Creates a new item in a SharePoint list. /// </summary> /// <param name="ListId">ID of the list.</param> /// <param name="FieldsJsonObject">JSON object containing the fields for the new item.</param> /// <param name="GraphListItem">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure CreateListItem(ListId: Text; FieldsJsonObject: JsonObject; var GraphListItem: Record "SharePoint Graph List Item" temporary): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; RequestJsonObj: JsonObject; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ListId = '' then begin SharePointGraphResponse.SetError(InvalidListIdErr); Session.LogMessage('0000RKO', InvalidListIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Create the request body with fields RequestJsonObj.Add('fields', FieldsJsonObject); // Post the request to create the item if not SharePointGraphRequestHelper.Post(SharePointGraphUriBuilder.GetCreateListItemEndpoint(ListId), RequestJsonObj, JsonResponse) then begin ErrorMessage := StrSubstNo(FailedToCreateListItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RKP', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphListItem.Init(); GraphListItem.ListId := CopyStr(ListId, 1, MaxStrLen(GraphListItem.ListId)); if not SharePointGraphParser.ParseListItemDetail(JsonResponse, GraphListItem) then begin SharePointGraphResponse.SetError(FailedToParseCreatedListItemErr); Session.LogMessage('0000RKQ', FailedToParseCreatedListItemErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphListItem.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RKR', StrSubstNo(OperationSuccessTelemetryMsg, 'CreateListItem'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Creates a new item in a SharePoint list with a simple title. /// </summary> /// <param name="ListId">ID of the list.</param> /// <param name="Title">Title for the new item.</param> /// <param name="GraphListItem">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure CreateListItem(ListId: Text; Title: Text; var GraphListItem: Record "SharePoint Graph List Item" temporary): Codeunit "SharePoint Graph Response" var FieldsJsonObject: JsonObject; begin FieldsJsonObject.Add('Title', Title); exit(CreateListItem(ListId, FieldsJsonObject, GraphListItem)); end; /// <summary> /// Gets a single item from a SharePoint list. /// </summary> /// <param name="ListId">ID of the list.</param> /// <param name="ItemId">ID of the item.</param> /// <param name="GraphListItem">Record to store the result. If it already contains an item with the same ID from the same list, that item is refreshed; if that item belongs to a different list, the operation fails.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetListItem(ListId: Text; ItemId: Text; var GraphListItem: Record "SharePoint Graph List Item" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetListItem(ListId, ItemId, GraphListItem, GraphOptionalParameters)); end; /// <summary> /// Gets a single item from a SharePoint list. /// </summary> /// <param name="ListId">ID of the list.</param> /// <param name="ItemId">ID of the item.</param> /// <param name="GraphListItem">Record to store the result. If it already contains an item with the same ID from the same list, that item is refreshed; if that item belongs to a different list, the operation fails.</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> /// <remarks>The fields property is expanded by default so column values are included in the response; supplying an own $expand parameter overrides this.</remarks> procedure GetListItem(ListId: Text; ItemId: Text; var GraphListItem: Record "SharePoint Graph List Item" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; Endpoint: Text; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); if ListId = '' then begin SharePointGraphResponse.SetError(InvalidListIdErr); Session.LogMessage('0000UKB', InvalidListIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000UKC', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if GraphListItem.Get(CopyStr(ItemId, 1, MaxStrLen(GraphListItem.Id))) and (GraphListItem.ListId <> ListId) then begin ErrorMessage := StrSubstNo(ItemBufferCollisionErr, ItemId); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000UKD', ItemBufferCollisionTelemetryErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; Endpoint := SharePointGraphUriBuilder.GetListItemByIdEndpoint(ListId, ItemId); // Appended to the endpoint instead of SetODataQueryParameter: codeunits are reference types, so setting it on // GraphOptionalParameters would leak $expand=fields into the caller's subsequent requests. if not GraphOptionalParameters.GetODataQueryParameters().ContainsKey(Format(Enum::"Graph OData Query Parameter"::expand)) then Endpoint += '?$expand=fields'; if not SharePointGraphRequestHelper.Get(Endpoint, JsonResponse, GraphOptionalParameters) then begin ErrorMessage := StrSubstNo(FailedToRetrieveListItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000UKE', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphListItem.Init(); GraphListItem.ListId := CopyStr(ListId, 1, MaxStrLen(GraphListItem.ListId)); if not SharePointGraphParser.ParseListItemDetail(JsonResponse, GraphListItem) then begin SharePointGraphResponse.SetError(FailedToParseListItemErr); Session.LogMessage('0000UKF', FailedToParseListItemErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if not GraphListItem.Insert() then GraphListItem.Modify(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000UKG', StrSubstNo(OperationSuccessTelemetryMsg, 'GetListItem'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Updates an existing list item's fields. /// </summary> /// <param name="ListId">ID of the list.</param> /// <param name="ItemId">ID of the item to update.</param> /// <param name="FieldsJsonObject">JSON object containing the fields to update.</param> /// <param name="GraphListItem">Record to store the updated item details. If it already contains an item with the same ID from the same list, that item is refreshed; if that item belongs to a different list, the operation fails.</param> /// <returns>An operation response object containing the result of the operation.</returns> /// <remarks>The PATCH response is a fieldValueSet, so only Title and the field values are refreshed. If the record already held the item, ContentType, WebUrl, CreatedDateTime and LastModifiedDateTime keep their previous values; otherwise they are blank. Use GetListItem to retrieve current values for those fields.</remarks> procedure UpdateListItem(ListId: Text; ItemId: Text; FieldsJsonObject: JsonObject; var GraphListItem: Record "SharePoint Graph List Item" temporary): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; ErrorMessage: Text; IsExistingItem: Boolean; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); if ListId = '' then begin SharePointGraphResponse.SetError(InvalidListIdErr); Session.LogMessage('0000UKH', InvalidListIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000UKI', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if FieldsJsonObject.Keys().Count() = 0 then begin SharePointGraphResponse.SetError(InvalidFieldsErr); Session.LogMessage('0000UKJ', InvalidFieldsErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; IsExistingItem := GraphListItem.Get(CopyStr(ItemId, 1, MaxStrLen(GraphListItem.Id))); if IsExistingItem and (GraphListItem.ListId <> ListId) then begin ErrorMessage := StrSubstNo(ItemBufferCollisionErr, ItemId); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000UKK', ItemBufferCollisionTelemetryErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if not SharePointGraphRequestHelper.Patch(SharePointGraphUriBuilder.GetUpdateListItemFieldsEndpoint(ListId, ItemId), FieldsJsonObject, JsonResponse) then begin ErrorMessage := StrSubstNo(FailedToUpdateListItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000UKL', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if not IsExistingItem then begin GraphListItem.Init(); GraphListItem.Id := CopyStr(ItemId, 1, MaxStrLen(GraphListItem.Id)); GraphListItem.ListId := CopyStr(ListId, 1, MaxStrLen(GraphListItem.ListId)); end; if not SharePointGraphParser.ParseListItemFieldValueSet(JsonResponse, GraphListItem) then begin SharePointGraphResponse.SetError(FailedToParseUpdatedListItemErr); Session.LogMessage('0000UKW', FailedToParseUpdatedListItemErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if IsExistingItem then GraphListItem.Modify() else GraphListItem.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000UKM', StrSubstNo(OperationSuccessTelemetryMsg, 'UpdateListItem'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; #endregion #region Drive and Items /// <summary> /// Gets the default document library (drive) for the site. /// </summary> /// <param name="DriveId">ID of the default drive.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDefaultDrive(var DriveId: Text): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Get default drive ID if not already cached if DefaultDriveId = '' then begin ErrorMessage := StrSubstNo(FailedToRetrieveDefaultDriveErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RKS', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; DriveId := DefaultDriveId; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RKT', StrSubstNo(OperationSuccessTelemetryMsg, 'GetDefaultDrive'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets all drives (document libraries) available on the site with detailed information. /// </summary> /// <param name="GraphDrives">Collection of the result (temporary record).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDrives(var GraphDrives: Record "SharePoint Graph Drive" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetDrives(GraphDrives, GraphOptionalParameters)); end; /// <summary> /// Gets all drives (document libraries) available on the site with detailed information. /// </summary> /// <param name="GraphDrives">Collection of the result (temporary record).</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDrives(var GraphDrives: Record "SharePoint Graph Drive" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonArray: JsonArray; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Use Graph pagination to get all pages automatically if not SharePointGraphRequestHelper.GetAllPages(SharePointGraphUriBuilder.GetDrivesEndpoint(), GraphOptionalParameters, JsonArray) then begin ErrorMessage := StrSubstNo(FailedToRetrieveDrivesErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RKU', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Parse the combined results from all pages if not SharePointGraphParser.ParseDriveCollection(JsonArray, GraphDrives) then begin SharePointGraphResponse.SetError(FailedToParseDrivesErr); Session.LogMessage('0000RKV', FailedToParseDrivesErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RKW', StrSubstNo(OperationSuccessTelemetryMsg, 'GetDrives'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets a drive (document library) by ID with detailed information. /// </summary> /// <param name="DriveId">ID of the drive to retrieve.</param> /// <param name="GraphDrive">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDrive(DriveId: Text; var GraphDrive: Record "SharePoint Graph Drive" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetDrive(DriveId, GraphDrive, GraphOptionalParameters)); end; /// <summary> /// Gets a drive (document library) by ID with detailed information. /// </summary> /// <param name="DriveId">ID of the drive to retrieve.</param> /// <param name="GraphDrive">Record to store the result.</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDrive(DriveId: Text; var GraphDrive: Record "SharePoint Graph Drive" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; DriveEndpoint: Text; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if DriveId = '' then begin SharePointGraphResponse.SetError(InvalidDriveIdErr); Session.LogMessage('0000RKX', InvalidDriveIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Construct drive endpoint for specific drive ID DriveEndpoint := SharePointGraphUriBuilder.GetSpecificDriveEndpoint(DriveId); // Make the API request if not SharePointGraphRequestHelper.Get(DriveEndpoint, JsonResponse, GraphOptionalParameters) then begin ErrorMessage := StrSubstNo(FailedToRetrieveDriveErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RKY', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDrive.Init(); if not SharePointGraphParser.ParseDriveDetail(JsonResponse, GraphDrive) then begin SharePointGraphResponse.SetError(FailedToParseDriveErr); Session.LogMessage('0000RKZ', FailedToParseDriveErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDrive.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RL0', StrSubstNo(OperationSuccessTelemetryMsg, 'GetDrive'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets the default document library (drive) for the site with detailed information. /// </summary> /// <param name="GraphDrive">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDefaultDrive(var GraphDrive: Record "SharePoint Graph Drive" temporary): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; JsonResponse: JsonObject; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Make the API request if not SharePointGraphRequestHelper.Get(SharePointGraphUriBuilder.GetDriveEndpoint(), JsonResponse, GraphOptionalParameters) then begin ErrorMessage := StrSubstNo(FailedToRetrieveDefaultDriveErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RL1', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDrive.Init(); if not SharePointGraphParser.ParseDriveDetail(JsonResponse, GraphDrive) then begin SharePointGraphResponse.SetError(FailedToParseDriveErr); Session.LogMessage('0000RL2', FailedToParseDriveErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDrive.Insert(); // Update DefaultDriveId while we're at it DefaultDriveId := CopyStr(GraphDrive.Id, 1, MaxStrLen(DefaultDriveId)); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RL3', StrSubstNo(OperationSuccessTelemetryMsg, 'GetDefaultDrive'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets items in the root folder of the default drive. /// </summary> /// <param name="GraphDriveItems">Collection of the result (temporary record).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetRootItems(var GraphDriveItems: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetRootItems(GraphDriveItems, GraphOptionalParameters)); end; /// <summary> /// Gets items in the root folder of the default drive. /// </summary> /// <param name="GraphDriveItems">Collection of the result (temporary record).</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetRootItems(var GraphDriveItems: Record "SharePoint Graph Drive Item" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonArray: JsonArray; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Ensure we have Default Drive ID EnsureDefaultDriveId(); if DefaultDriveId = '' then begin SharePointGraphResponse.SetError(NoDefaultDriveIdErr); Session.LogMessage('0000RL4', NoDefaultDriveIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Use Graph pagination to get all pages automatically if not SharePointGraphRequestHelper.GetAllPages(SharePointGraphUriBuilder.GetDriveRootChildrenEndpoint(), GraphOptionalParameters, JsonArray) then begin ErrorMessage := StrSubstNo(FailedToRetrieveRootItemsErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RL5', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Parse the combined results from all pages if not SharePointGraphParser.ParseDriveItemCollection(JsonArray, DefaultDriveId, GraphDriveItems) then begin SharePointGraphResponse.SetError(FailedToParseRootItemsErr); Session.LogMessage('0000RL6', FailedToParseRootItemsErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RL7', StrSubstNo(OperationSuccessTelemetryMsg, 'GetRootItems'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets children of a folder by the folder's ID. /// </summary> /// <param name="FolderId">ID of the folder.</param> /// <param name="GraphDriveItems">Collection of the result (temporary record).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetFolderItems(FolderId: Text; var GraphDriveItems: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetFolderItems(FolderId, GraphDriveItems, GraphOptionalParameters)); end; /// <summary> /// Gets children of a folder by the folder's ID. /// </summary> /// <param name="FolderId">ID of the folder.</param> /// <param name="GraphDriveItems">Collection of the result (temporary record).</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetFolderItems(FolderId: Text; var GraphDriveItems: Record "SharePoint Graph Drive Item" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonArray: JsonArray; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if FolderId = '' then begin SharePointGraphResponse.SetError(InvalidFolderIdErr); Session.LogMessage('0000RL8', InvalidFolderIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Ensure we have Default Drive ID EnsureDefaultDriveId(); if DefaultDriveId = '' then begin SharePointGraphResponse.SetError(NoDefaultDriveIdErr); Session.LogMessage('0000RL9', NoDefaultDriveIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Use Graph pagination to get all pages automatically if not SharePointGraphRequestHelper.GetAllPages(SharePointGraphUriBuilder.GetDriveItemChildrenByIdEndpoint(FolderId), GraphOptionalParameters, JsonArray) then begin ErrorMessage := StrSubstNo(FailedToRetrieveFolderItemsErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RLA', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Parse the combined results from all pages if not SharePointGraphParser.ParseDriveItemCollection(JsonArray, DefaultDriveId, GraphDriveItems) then begin SharePointGraphResponse.SetError(FailedToParseFolderItemsErr); Session.LogMessage('0000RLB', FailedToParseFolderItemsErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RLC', StrSubstNo(OperationSuccessTelemetryMsg, 'GetFolderItems'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets items from a path in the default drive. /// </summary> /// <param name="FolderPath">Path to the folder (e.g., 'Documents/Folder1').</param> /// <param name="GraphDriveItems">Collection of the result (temporary record).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetItemsByPath(FolderPath: Text; var GraphDriveItems: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetItemsByPath(FolderPath, GraphDriveItems, GraphOptionalParameters)); end; /// <summary> /// Gets items from a path in the default drive. /// </summary> /// <param name="FolderPath">Path to the folder (e.g., 'Documents/Folder1').</param> /// <param name="GraphDriveItems">Collection of the result (temporary record).</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetItemsByPath(FolderPath: Text; var GraphDriveItems: Record "SharePoint Graph Drive Item" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonArray: JsonArray; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Handle empty path as root if FolderPath = '' then exit(GetRootItems(GraphDriveItems, GraphOptionalParameters)); // Remove leading slash if present FolderPath := FolderPath.TrimStart('/'); // Use Graph pagination to get all pages automatically if not SharePointGraphRequestHelper.GetAllPages(SharePointGraphUriBuilder.GetDriveItemChildrenByPathEndpoint(FolderPath), GraphOptionalParameters, JsonArray) then begin ErrorMessage := StrSubstNo(FailedToRetrieveItemsByPathErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RLD', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Parse the combined results from all pages if not SharePointGraphParser.ParseDriveItemCollection(JsonArray, DefaultDriveId, GraphDriveItems) then begin SharePointGraphResponse.SetError(FailedToParseItemsByPathErr); Session.LogMessage('0000RLE', FailedToParseItemsByPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RLF', StrSubstNo(OperationSuccessTelemetryMsg, 'GetItemsByPath'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Uploads a file to a folder in a specific drive (document library) with specified conflict behavior. /// </summary> /// <param name="DriveId">ID of the drive (document library).</param> /// <param name="FolderPath">Path to the folder (e.g., 'Documents').</param> /// <param name="FileName">Name of the file to upload.</param> /// <param name="FileInStream">Content of the file.</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <param name="ConflictBehavior">How to handle conflicts if a file with the same name exists</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure UploadFile(DriveId: Text; FolderPath: Text; FileName: Text; FileInStream: InStream; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary; ConflictBehavior: Enum "Graph ConflictBehavior"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; JsonResponse: JsonObject; EffectiveDriveId: Text; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if FileName = '' then begin SharePointGraphResponse.SetError(InvalidFileNameErr); Session.LogMessage('0000RLG', InvalidFileNameErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Use default drive ID if none specified if DriveId = '' then begin EnsureDefaultDriveId(); EffectiveDriveId := DefaultDriveId; end else EffectiveDriveId := DriveId; // Remove leading slash if present FolderPath := FolderPath.TrimStart('/'); // Configure conflict behavior SharePointGraphRequestHelper.ConfigureConflictBehavior(GraphOptionalParameters, ConflictBehavior); // Put the file content in the specific drive if not SharePointGraphRequestHelper.UploadFile(SharePointGraphUriBuilder.GetSpecificDriveUploadEndpoint(EffectiveDriveId, FolderPath, FileName), FileInStream, GraphOptionalParameters, JsonResponse) then begin ErrorMessage := StrSubstNo(FailedToUploadFileErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RLH', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Init(); GraphDriveItem.DriveId := CopyStr(EffectiveDriveId, 1, MaxStrLen(GraphDriveItem.DriveId)); if not SharePointGraphParser.ParseDriveItemDetail(JsonResponse, GraphDriveItem) then begin SharePointGraphResponse.SetError(FailedToParseUploadedFileErr); Session.LogMessage('0000RLI', FailedToParseUploadedFileErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RLJ', StrSubstNo(OperationSuccessTelemetryMsg, 'UploadFile'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Uploads a file to a folder in a specific drive (document library). /// </summary> /// <param name="DriveId">ID of the drive (document library).</param> /// <param name="FolderPath">Path to the folder (e.g., 'Documents').</param> /// <param name="FileName">Name of the file to upload.</param> /// <param name="FileInStream">Content of the file.</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure UploadFile(DriveId: Text; FolderPath: Text; FileName: Text; FileInStream: InStream; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" begin exit(UploadFile(DriveId, FolderPath, FileName, FileInStream, GraphDriveItem, Enum::"Graph ConflictBehavior"::Replace)); end; /// <summary> /// Uploads a large file to a folder on SharePoint using chunked upload for better performance and reliability. /// </summary> /// <param name="DriveId">ID of the drive (document library), or empty for default drive.</param> /// <param name="FolderPath">Path to the folder (e.g., 'Documents').</param> /// <param name="FileName">Name of the file to upload.</param> /// <param name="FileInStream">Content of the file.</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure UploadLargeFile(DriveId: Text; FolderPath: Text; FileName: Text; FileInStream: InStream; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" var GraphConflictBehavior: Enum "Graph ConflictBehavior"; begin exit(UploadLargeFile(DriveId, FolderPath, FileName, FileInStream, GraphDriveItem, GraphConflictBehavior::Replace)); end; /// <summary> /// Uploads a large file to a folder on SharePoint using chunked upload with specified conflict behavior. /// </summary> /// <param name="DriveId">ID of the drive (document library), or empty for default drive.</param> /// <param name="FolderPath">Path to the folder (e.g., 'Documents').</param> /// <param name="FileName">Name of the file to upload.</param> /// <param name="FileInStream">Content of the file.</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <param name="ConflictBehavior">How to handle conflicts if a file with the same name exists</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure UploadLargeFile(DriveId: Text; FolderPath: Text; FileName: Text; FileInStream: InStream; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary; ConflictBehavior: Enum "Graph ConflictBehavior"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; TempBlob: Codeunit "Temp Blob"; ChunkInStream: InStream; ChunkOutStream: OutStream; JsonResponse: JsonObject; CompleteResponseJson: JsonObject; Endpoint: Text; UploadUrl: Text; ContentRange: Text; EffectiveDriveId: Text; ErrorMessage: Text; FileSize: Integer; ChunkSize: Integer; BytesInChunk: Integer; TotalBytesRead: Integer; MinChunkSize: Integer; ChunkMultiple: Integer; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if FileName = '' then begin SharePointGraphResponse.SetError(InvalidFileNameErr); Session.LogMessage('0000RLK', InvalidFileNameErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Use default drive ID if none specified if DriveId = '' then begin EnsureDefaultDriveId(); if DefaultDriveId = '' then begin SharePointGraphResponse.SetError(NoDefaultDriveIdErr); Session.LogMessage('0000RLL', NoDefaultDriveIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; EffectiveDriveId := DefaultDriveId; end else EffectiveDriveId := DriveId; // Remove leading slash if present FolderPath := FolderPath.TrimStart('/'); // Configure conflict behavior SharePointGraphRequestHelper.ConfigureConflictBehavior(GraphOptionalParameters, ConflictBehavior); // Prepare the upload session endpoint if EffectiveDriveId = DefaultDriveId then Endpoint := SharePointGraphUriBuilder.GetDriveItemByPathEndpoint(FolderPath + '/' + FileName) else Endpoint := SharePointGraphUriBuilder.GetSpecificDriveUploadEndpoint(EffectiveDriveId, FolderPath, FileName); FileSize := FileInStream.Length(); if FileSize <= 0 then begin SharePointGraphResponse.SetError(InvalidFileSizeErr); Session.LogMessage('0000RLM', InvalidFileSizeErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Create upload session if not SharePointGraphRequestHelper.CreateUploadSession(Endpoint, FileName, FileSize, GraphOptionalParameters, ConflictBehavior, UploadUrl) then begin ErrorMessage := StrSubstNo(FailedToCreateUploadSessionErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RLN', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Microsoft requires chunks to be multiples of 320 KiB (327,680 bytes) ChunkMultiple := 320 * 1024; // 320 KiB MinChunkSize := ChunkMultiple; // Minimum allowed size // Use 4 MB chunks as recommended by Microsoft for optimum performance ChunkSize := 4 * 1024 * 1024; // 4 MB // Ensure chunk size is a multiple of 320 KiB ChunkSize := Round(ChunkSize / ChunkMultiple, 1, '<') * ChunkMultiple; // For small files, use at least the minimum size but ensure it doesn't exceed file size if FileSize < ChunkSize then ChunkSize := MinChunkSize; // Reset the stream position to beginning FileInStream.ResetPosition(); TotalBytesRead := 0; // Read and upload chunks until the entire file is uploaded while TotalBytesRead < FileSize do begin // Clear temp blob for new chunk Clear(TempBlob); TempBlob.CreateOutStream(ChunkOutStream); // Determine bytes to copy in this chunk BytesInChunk := ChunkSize; if (FileSize - TotalBytesRead) < ChunkSize then // For the last chunk, ensure it's still a multiple of 320 KiB unless it's the final remainder if (FileSize - TotalBytesRead) > MinChunkSize then BytesInChunk := Round((FileSize - TotalBytesRead) / ChunkMultiple, 1, '<') * ChunkMultiple else BytesInChunk := FileSize - TotalBytesRead; // Copy directly from source stream into the chunk stream CopyStream(ChunkOutStream, FileInStream, BytesInChunk); // Prepare content range header - must follow format "bytes startPosition-endPosition/totalSize" ContentRange := StrSubstNo(ContentRangeHeaderLbl, TotalBytesRead, TotalBytesRead + BytesInChunk - 1, FileSize); // Get the input stream for the chunk TempBlob.CreateInStream(ChunkInStream); // Upload the chunk - use the exact URL returned from the upload session without modification if not SharePointGraphRequestHelper.UploadChunk(UploadUrl, ChunkInStream, ContentRange, JsonResponse) then begin ErrorMessage := StrSubstNo(FailedToUploadChunkErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RLO', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Check if upload is complete (last chunk response will contain the item details) if JsonResponse.Contains('id') then CompleteResponseJson := JsonResponse; // Update total bytes read TotalBytesRead += BytesInChunk; end; if not CompleteResponseJson.Contains('id') then begin SharePointGraphResponse.SetError(NoUploadResponseErr); Session.LogMessage('0000RLP', NoUploadResponseErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Init(); GraphDriveItem.DriveId := CopyStr(EffectiveDriveId, 1, MaxStrLen(GraphDriveItem.DriveId)); if not SharePointGraphParser.ParseDriveItemDetail(CompleteResponseJson, GraphDriveItem) then begin SharePointGraphResponse.SetError(FailedToParseChunkedUploadErr); Session.LogMessage('0000RLQ', FailedToParseChunkedUploadErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RLR', StrSubstNo(OperationSuccessTelemetryMsg, 'UploadLargeFile'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Creates a new folder in a specific drive (document library) with specified conflict behavior. /// </summary> /// <param name="DriveId">ID of the drive (document library).</param> /// <param name="FolderPath">Path where to create the folder (e.g., 'Documents').</param> /// <param name="FolderName">Name of the new folder.</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <param name="ConflictBehavior">How to handle conflicts if a folder with the same name exists</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure CreateFolder(DriveId: Text; FolderPath: Text; FolderName: Text; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary; ConflictBehavior: Enum "Graph ConflictBehavior"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; GraphOptionalParameters: Codeunit "Graph Optional Parameters"; JsonResponse: JsonObject; RequestJsonObj: JsonObject; FolderJsonObj: JsonObject; Endpoint: Text; EffectiveDriveId: Text; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if FolderName = '' then begin SharePointGraphResponse.SetError(InvalidFolderNameErr); Session.LogMessage('0000RLS', InvalidFolderNameErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Use default drive ID if none specified if DriveId = '' then begin EnsureDefaultDriveId(); EffectiveDriveId := DefaultDriveId; end else EffectiveDriveId := DriveId; // Remove leading slash if present FolderPath := FolderPath.TrimStart('/'); // Create the request body with folder properties RequestJsonObj.Add('name', FolderName); RequestJsonObj.Add('folder', FolderJsonObj); // Configure conflict behavior SharePointGraphRequestHelper.ConfigureConflictBehavior(GraphOptionalParameters, ConflictBehavior); // Set endpoint for creating folder in specific drive if FolderPath = '' then Endpoint := SharePointGraphUriBuilder.GetSpecificDriveRootChildrenEndpoint(EffectiveDriveId) else Endpoint := SharePointGraphUriBuilder.GetSpecificDriveItemChildrenByPathEndpoint(EffectiveDriveId, FolderPath); // Post the request to create the folder if not SharePointGraphRequestHelper.Post(Endpoint, RequestJsonObj, GraphOptionalParameters, JsonResponse) then begin ErrorMessage := StrSubstNo(FailedToCreateFolderErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RLT', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Init(); GraphDriveItem.DriveId := CopyStr(EffectiveDriveId, 1, MaxStrLen(GraphDriveItem.DriveId)); if not SharePointGraphParser.ParseDriveItemDetail(JsonResponse, GraphDriveItem) then begin SharePointGraphResponse.SetError(FailedToParseCreatedFolderErr); Session.LogMessage('0000RLU', FailedToParseCreatedFolderErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RLV', StrSubstNo(OperationSuccessTelemetryMsg, 'CreateFolder'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Creates a new folder in a specific drive (document library). /// </summary> /// <param name="DriveId">ID of the drive (document library).</param> /// <param name="FolderPath">Path where to create the folder (e.g., 'Documents').</param> /// <param name="FolderName">Name of the new folder.</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure CreateFolder(DriveId: Text; FolderPath: Text; FolderName: Text; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" begin exit(CreateFolder(DriveId, FolderPath, FolderName, GraphDriveItem, Enum::"Graph ConflictBehavior"::Fail)); end; /// <summary> /// Downloads a file. /// </summary> /// <param name="ItemId">ID of the file to download.</param> /// <param name="TempBlob">TempBlob to receive the file content.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure DownloadFile(ItemId: Text; var TempBlob: Codeunit "Temp Blob"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000RLW', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Make the API request if not SharePointGraphRequestHelper.DownloadFile(SharePointGraphUriBuilder.GetDriveItemContentByIdEndpoint(ItemId), TempBlob) then begin ErrorMessage := StrSubstNo(FailedToDownloadFileErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RLX', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RLY', StrSubstNo(OperationSuccessTelemetryMsg, 'DownloadFile'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Downloads a file by path. /// </summary> /// <param name="FilePath">Path to the file (e.g., 'Documents/file.docx').</param> /// <param name="TempBlob">TempBlob to receive the file content.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure DownloadFileByPath(FilePath: Text; var TempBlob: Codeunit "Temp Blob"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if FilePath = '' then begin SharePointGraphResponse.SetError(InvalidFilePathErr); Session.LogMessage('0000RLZ', InvalidFilePathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Remove leading slash if present FilePath := FilePath.TrimStart('/'); // Make the API request if not SharePointGraphRequestHelper.DownloadFile(SharePointGraphUriBuilder.GetDriveItemContentByPathEndpoint(FilePath), TempBlob) then begin ErrorMessage := StrSubstNo(FailedToDownloadFileByPathErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RM0', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RM1', StrSubstNo(OperationSuccessTelemetryMsg, 'DownloadFileByPath'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Downloads a large file using chunked download to overcome Business Central's 150MB HTTP response limit. /// </summary> /// <param name="ItemId">ID of the file to download.</param> /// <param name="FileOutStream">OutStream to receive the file content.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure DownloadLargeFile(ItemId: Text; var TempBlob: Codeunit "Temp Blob"): Codeunit "SharePoint Graph Response" var TempGraphDriveItem: Record "SharePoint Graph Drive Item"; SharePointGraphResponse: Codeunit "SharePoint Graph Response"; ChunkTempBlob: Codeunit "Temp Blob"; ChunkInStream: InStream; FileOutStream: OutStream; FileSize: BigInteger; ChunkSize: BigInteger; RangeStart: BigInteger; RangeEnd: BigInteger; Endpoint: Text; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000RM2', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // First, get the file size if not GetDriveItem(ItemId, TempGraphDriveItem).IsSuccessful() then begin ErrorMessage := StrSubstNo(FailedToGetFileSizeErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RM3', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; FileSize := TempGraphDriveItem.Size; if FileSize <= 0 then begin SharePointGraphResponse.SetError(InvalidFileSizeErr); Session.LogMessage('0000RM4', InvalidFileSizeErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // 100MB chunk size (104,857,600 bytes) - safely under 150MB Business Central limit ChunkSize := 100 * 1024 * 1024; RangeStart := 0; Endpoint := SharePointGraphUriBuilder.GetDriveItemContentByIdEndpoint(ItemId); TempBlob.CreateOutStream(FileOutStream); // Download file in chunks while RangeStart < FileSize do begin Clear(ChunkTempBlob); Clear(ChunkInStream); RangeEnd := RangeStart + ChunkSize - 1; if RangeEnd >= FileSize then RangeEnd := FileSize - 1; if not SharePointGraphRequestHelper.DownloadChunk(Endpoint, RangeStart, RangeEnd, ChunkTempBlob) then begin ErrorMessage := StrSubstNo(FailedToDownloadChunkErr, RangeStart, RangeEnd, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RM5', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Write chunk to output Blob ChunkTempBlob.CreateInStream(ChunkInStream); CopyStream(FileOutStream, ChunkInStream); RangeStart := RangeEnd + 1; end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RM6', StrSubstNo(OperationSuccessTelemetryMsg, 'DownloadLargeFile'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Downloads a large file by path using chunked download to overcome Business Central's 150MB HTTP response limit. /// </summary> /// <param name="FilePath">Path to the file (e.g., 'Documents/file.docx').</param> /// <param name="FileOutStream">OutStream to receive the file content.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure DownloadLargeFileByPath(FilePath: Text; var TempBlob: Codeunit "Temp Blob"): Codeunit "SharePoint Graph Response" var TempGraphDriveItem: Record "SharePoint Graph Drive Item"; SharePointGraphResponse: Codeunit "SharePoint Graph Response"; ChunkTempBlob: Codeunit "Temp Blob"; ChunkInStream: InStream; FileOutStream: OutStream; FileSize: BigInteger; ChunkSize: BigInteger; RangeStart: BigInteger; RangeEnd: BigInteger; Endpoint: Text; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if FilePath = '' then begin SharePointGraphResponse.SetError(InvalidFilePathErr); Session.LogMessage('0000RM7', InvalidFilePathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Remove leading slash if present FilePath := FilePath.TrimStart('/'); // First, get the file size if not GetDriveItemByPath(FilePath, TempGraphDriveItem).IsSuccessful() then begin ErrorMessage := StrSubstNo(FailedToGetFileSizeErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RM8', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; FileSize := TempGraphDriveItem.Size; if FileSize <= 0 then begin SharePointGraphResponse.SetError(InvalidFileSizeErr); Session.LogMessage('0000RM9', InvalidFileSizeErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // 100MB chunk size (104,857,600 bytes) - safely under 150MB Business Central limit ChunkSize := 100 * 1024 * 1024; RangeStart := 0; Endpoint := SharePointGraphUriBuilder.GetDriveItemContentByPathEndpoint(FilePath); TempBlob.CreateOutStream(FileOutStream); // Download file in chunks while RangeStart < FileSize do begin Clear(ChunkTempBlob); RangeEnd := RangeStart + ChunkSize - 1; if RangeEnd >= FileSize then RangeEnd := FileSize - 1; if not SharePointGraphRequestHelper.DownloadChunk(Endpoint, RangeStart, RangeEnd, ChunkTempBlob) then begin ErrorMessage := StrSubstNo(FailedToDownloadChunkErr, RangeStart, RangeEnd, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RMA', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Write chunk to output Blob ChunkTempBlob.CreateInStream(ChunkInStream); CopyStream(FileOutStream, ChunkInStream); RangeStart := RangeEnd + 1; end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMB', StrSubstNo(OperationSuccessTelemetryMsg, 'DownloadLargeFileByPath'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets a file or folder by ID. /// </summary> /// <param name="ItemId">ID of the item to retrieve.</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDriveItem(ItemId: Text; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetDriveItem(ItemId, GraphDriveItem, GraphOptionalParameters)); end; /// <summary> /// Gets a file or folder by path. /// </summary> /// <param name="ItemPath">Path to the item (e.g., 'Documents/file.docx').</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDriveItemByPath(ItemPath: Text; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" var GraphOptionalParameters: Codeunit "Graph Optional Parameters"; begin exit(GetDriveItemByPath(ItemPath, GraphDriveItem, GraphOptionalParameters)); end; /// <summary> /// Gets a file or folder by path. /// </summary> /// <param name="ItemPath">Path to the item (e.g., 'Documents/file.docx').</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDriveItemByPath(ItemPath: Text; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemPath = '' then begin SharePointGraphResponse.SetError(InvalidItemPathErr); Session.LogMessage('0000RMC', InvalidItemPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Remove leading slash if present ItemPath := ItemPath.TrimStart('/'); // Make the API request if not SharePointGraphRequestHelper.Get(SharePointGraphUriBuilder.GetDriveItemByPathEndpoint(ItemPath), JsonResponse, GraphOptionalParameters) then begin ErrorMessage := StrSubstNo(FailedToRetrieveDriveItemByPathErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RMD', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Init(); GraphDriveItem.DriveId := CopyStr(DefaultDriveId, 1, MaxStrLen(GraphDriveItem.DriveId)); if not SharePointGraphParser.ParseDriveItemDetail(JsonResponse, GraphDriveItem) then begin SharePointGraphResponse.SetError(FailedToParseDriveItemByPathErr); Session.LogMessage('0000RME', FailedToParseDriveItemByPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMF', StrSubstNo(OperationSuccessTelemetryMsg, 'GetDriveItemByPath'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Gets a file or folder by ID. /// </summary> /// <param name="ItemId">ID of the item to retrieve.</param> /// <param name="GraphDriveItem">Record to store the result.</param> /// <param name="GraphOptionalParameters">A wrapper for optional header and query parameters.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure GetDriveItem(ItemId: Text; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary; GraphOptionalParameters: Codeunit "Graph Optional Parameters"): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000RMG', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Make the API request if not SharePointGraphRequestHelper.Get(SharePointGraphUriBuilder.GetDriveItemByIdEndpoint(ItemId), JsonResponse, GraphOptionalParameters) then begin ErrorMessage := StrSubstNo(FailedToRetrieveDriveItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RMH', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Init(); GraphDriveItem.DriveId := CopyStr(DefaultDriveId, 1, MaxStrLen(GraphDriveItem.DriveId)); if not SharePointGraphParser.ParseDriveItemDetail(JsonResponse, GraphDriveItem) then begin SharePointGraphResponse.SetError(FailedToParseDriveItemErr); Session.LogMessage('0000RMI', FailedToParseDriveItemErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; GraphDriveItem.Insert(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMJ', StrSubstNo(OperationSuccessTelemetryMsg, 'GetDriveItem'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Deletes a drive item (file or folder) by ID. /// </summary> /// <param name="ItemId">ID of the item to delete.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure DeleteItem(ItemId: Text): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000RMK', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Make the DELETE request if not SharePointGraphRequestHelper.Delete(SharePointGraphUriBuilder.GetDriveItemByIdEndpoint(ItemId)) then begin // 404 is success - item already doesn't exist if SharePointGraphRequestHelper.GetDiagnostics().GetHttpStatusCode() = 404 then begin SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RML', StrSubstNo(OperationSuccessTelemetryMsg, 'DeleteItem'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; ErrorMessage := StrSubstNo(FailedToDeleteItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RMM', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMN', StrSubstNo(OperationSuccessTelemetryMsg, 'DeleteItem'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Deletes a drive item (file or folder) by path. /// </summary> /// <param name="ItemPath">Path to the item (e.g., 'Documents/file.docx').</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure DeleteItemByPath(ItemPath: Text): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemPath = '' then begin SharePointGraphResponse.SetError(InvalidFilePathErr); Session.LogMessage('0000RMO', InvalidFilePathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Remove leading slash if present ItemPath := ItemPath.TrimStart('/'); // Make the DELETE request if not SharePointGraphRequestHelper.Delete(SharePointGraphUriBuilder.GetDriveItemByPathEndpoint(ItemPath)) then begin // 404 is success - item already doesn't exist if SharePointGraphRequestHelper.GetDiagnostics().GetHttpStatusCode() = 404 then begin SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMP', StrSubstNo(OperationSuccessTelemetryMsg, 'DeleteItemByPath'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; ErrorMessage := StrSubstNo(FailedToDeleteItemByPathErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RMQ', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMR', StrSubstNo(OperationSuccessTelemetryMsg, 'DeleteItemByPath'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Checks if a drive item (file or folder) exists by ID. /// </summary> /// <param name="ItemId">ID of the item to check.</param> /// <param name="Exists">True if the item exists, false if it doesn't exist (404).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure ItemExists(ItemId: Text; var Exists: Boolean): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; HttpStatusCode: Integer; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000RMS', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); Exists := false; exit(SharePointGraphResponse); end; // Try to get the item if not SharePointGraphRequestHelper.Get(SharePointGraphUriBuilder.GetDriveItemByIdEndpoint(ItemId), JsonResponse) then begin HttpStatusCode := SharePointGraphRequestHelper.GetDiagnostics().GetHttpStatusCode(); // 404 means item doesn't exist - this is a successful check, just with a negative result if HttpStatusCode = 404 then begin Exists := false; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMT', StrSubstNo(OperationSuccessTelemetryMsg, 'ItemExists'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // For other errors (401, 403, 429, 500, etc.), return error response ErrorMessage := StrSubstNo(FailedToRetrieveDriveItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetErrorMessage()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RMU', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); Exists := false; exit(SharePointGraphResponse); end; // Item exists Exists := true; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMV', StrSubstNo(OperationSuccessTelemetryMsg, 'ItemExists'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Checks if a drive item (file or folder) exists by path. /// </summary> /// <param name="ItemPath">Path to the item (e.g., 'Documents/file.docx').</param> /// <param name="Exists">True if the item exists, false if it doesn't exist (404).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure ItemExistsByPath(ItemPath: Text; var Exists: Boolean): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; JsonResponse: JsonObject; HttpStatusCode: Integer; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemPath = '' then begin SharePointGraphResponse.SetError(InvalidItemPathErr); Session.LogMessage('0000RMW', InvalidItemPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); Exists := false; exit(SharePointGraphResponse); end; // Remove leading slash if present ItemPath := ItemPath.TrimStart('/'); // Try to get the item if not SharePointGraphRequestHelper.Get(SharePointGraphUriBuilder.GetDriveItemByPathEndpoint(ItemPath), JsonResponse) then begin HttpStatusCode := SharePointGraphRequestHelper.GetDiagnostics().GetHttpStatusCode(); // 404 means item doesn't exist - this is a successful check, just with a negative result if HttpStatusCode = 404 then begin Exists := false; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMX', StrSubstNo(OperationSuccessTelemetryMsg, 'ItemExistsByPath'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // For other errors (401, 403, 429, 500, etc.), return error response ErrorMessage := StrSubstNo(FailedToRetrieveDriveItemByPathErr, SharePointGraphRequestHelper.GetDiagnostics().GetErrorMessage()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RMY', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); Exists := false; exit(SharePointGraphResponse); end; // Item exists Exists := true; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RMZ', StrSubstNo(OperationSuccessTelemetryMsg, 'ItemExistsByPath'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Copies a drive item (file or folder) to a new location by ID. /// </summary> /// <param name="ItemId">ID of the item to copy.</param> /// <param name="TargetFolderId">ID of the target folder.</param> /// <param name="NewName">New name for the copied item (optional).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure CopyItem(ItemId: Text; TargetFolderId: Text; NewName: Text): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; RequestBody: JsonObject; ParentReference: JsonObject; ResponseJson: JsonObject; CopyEndpoint: Text; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000RN0', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if TargetFolderId = '' then begin SharePointGraphResponse.SetError(InvalidTargetPathErr); Session.LogMessage('0000RN1', InvalidTargetPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Build the copy endpoint CopyEndpoint := SharePointGraphUriBuilder.GetCopyItemEndpoint(ItemId); // Build request body ParentReference.Add('driveId', DefaultDriveId); ParentReference.Add('id', TargetFolderId); RequestBody.Add('parentReference', ParentReference); if NewName <> '' then RequestBody.Add('name', NewName); // Make the POST request (copy is asynchronous - returns 202 Accepted) if not SharePointGraphRequestHelper.Post(CopyEndpoint, RequestBody, ResponseJson) then begin ErrorMessage := StrSubstNo(FailedToCopyItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RN2', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RN3', StrSubstNo(OperationSuccessTelemetryMsg, 'CopyItem'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Copies a drive item (file or folder) to a new location by path. /// </summary> /// <param name="ItemPath">Path to the item (e.g., 'Documents/file.docx').</param> /// <param name="TargetFolderPath">Path to the target folder (e.g., 'Documents/Archive').</param> /// <param name="NewName">New name for the copied item (optional).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure CopyItemByPath(ItemPath: Text; TargetFolderPath: Text; NewName: Text): Codeunit "SharePoint Graph Response" var TempGraphDriveItem: Record "SharePoint Graph Drive Item"; TempTargetFolderItem: Record "SharePoint Graph Drive Item"; SharePointGraphResponse: Codeunit "SharePoint Graph Response"; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemPath = '' then begin SharePointGraphResponse.SetError(InvalidFilePathErr); Session.LogMessage('0000RN4', InvalidFilePathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; if TargetFolderPath = '' then begin SharePointGraphResponse.SetError(InvalidTargetPathErr); Session.LogMessage('0000RN5', InvalidTargetPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Get the target folder ID first SharePointGraphResponse := GetDriveItemByPath(TargetFolderPath, TempTargetFolderItem); if not SharePointGraphResponse.IsSuccessful() then exit(SharePointGraphResponse); // Get the source item ID SharePointGraphResponse := GetDriveItemByPath(ItemPath, TempGraphDriveItem); if not SharePointGraphResponse.IsSuccessful() then exit(SharePointGraphResponse); // Now call CopyItem with IDs exit(CopyItem(TempGraphDriveItem.Id, TempTargetFolderItem.Id, NewName)); end; /// <summary> /// Moves a drive item (file or folder) to a new location by ID. /// </summary> /// <param name="ItemId">ID of the item to move.</param> /// <param name="TargetFolderId">ID of the target folder (optional).</param> /// <param name="NewName">New name for the moved item (optional).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure MoveItem(ItemId: Text; TargetFolderId: Text; NewName: Text): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; RequestBody: JsonObject; ParentReference: JsonObject; ResponseJson: JsonObject; ErrorMessage: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000RN6', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // At least one of target folder or new name must be provided if (TargetFolderId = '') and (NewName = '') then begin SharePointGraphResponse.SetError(InvalidTargetPathErr); Session.LogMessage('0000RN7', InvalidTargetPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Build request body for PATCH // Move is done by updating the parentReference and/or name if TargetFolderId <> '' then begin ParentReference.Add('id', TargetFolderId); RequestBody.Add('parentReference', ParentReference); end; if NewName <> '' then RequestBody.Add('name', NewName); // Make the PATCH request if not SharePointGraphRequestHelper.Patch(SharePointGraphUriBuilder.GetDriveItemByIdEndpoint(ItemId), RequestBody, ResponseJson) then begin ErrorMessage := StrSubstNo(FailedToMoveItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000RN8', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000RN9', StrSubstNo(OperationSuccessTelemetryMsg, 'MoveItem'), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; /// <summary> /// Moves a drive item (file or folder) to a new location by path. /// </summary> /// <param name="ItemPath">Path to the item (e.g., 'Documents/file.docx').</param> /// <param name="TargetFolderPath">Path to the target folder (optional).</param> /// <param name="NewName">New name for the moved item (optional).</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure MoveItemByPath(ItemPath: Text; TargetFolderPath: Text; NewName: Text): Codeunit "SharePoint Graph Response" var TempGraphDriveItem: Record "SharePoint Graph Drive Item"; TempTargetFolderItem: Record "SharePoint Graph Drive Item"; SharePointGraphResponse: Codeunit "SharePoint Graph Response"; TargetFolderId: Text; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); // Validate input if ItemPath = '' then begin SharePointGraphResponse.SetError(InvalidFilePathErr); Session.LogMessage('0000RNA', InvalidFilePathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // At least one of target folder or new name must be provided if (TargetFolderPath = '') and (NewName = '') then begin SharePointGraphResponse.SetError(InvalidTargetPathErr); Session.LogMessage('0000RNB', InvalidTargetPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; // Get the source item ID SharePointGraphResponse := GetDriveItemByPath(ItemPath, TempGraphDriveItem); if not SharePointGraphResponse.IsSuccessful() then exit(SharePointGraphResponse); // Get the target folder ID if provided if TargetFolderPath <> '' then begin SharePointGraphResponse := GetDriveItemByPath(TargetFolderPath, TempTargetFolderItem); if not SharePointGraphResponse.IsSuccessful() then exit(SharePointGraphResponse); TargetFolderId := TempTargetFolderItem.Id; end; // Now call MoveItem with IDs exit(MoveItem(TempGraphDriveItem.Id, TargetFolderId, NewName)); end; /// <summary> /// Updates a drive item's properties (name, description, etc.) by ID. /// </summary> /// <param name="ItemId">ID of the item to update.</param> /// <param name="UpdatePropertiesJsonObject">JSON object containing the properties to update.</param> /// <param name="GraphDriveItem">Record to store the updated item details. If it already contains an item with the same ID, that item is refreshed.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure UpdateDriveItem(ItemId: Text; UpdatePropertiesJsonObject: JsonObject; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" begin exit(UpdateDriveItem(ItemId, UpdatePropertiesJsonObject, GraphDriveItem, 'UpdateDriveItem')); end; local procedure UpdateDriveItem(ItemId: Text; UpdatePropertiesJsonObject: JsonObject; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary; OperationName: Text): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); if ItemId = '' then begin SharePointGraphResponse.SetError(InvalidItemIdErr); Session.LogMessage('0000UKN', InvalidItemIdErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl, 'OperationName', OperationName); exit(SharePointGraphResponse); end; if UpdatePropertiesJsonObject.Keys().Count() = 0 then begin SharePointGraphResponse.SetError(InvalidUpdateBodyErr); Session.LogMessage('0000UKO', InvalidUpdateBodyErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl, 'OperationName', OperationName); exit(SharePointGraphResponse); end; exit(UpdateDriveItemAtEndpoint(SharePointGraphUriBuilder.GetDriveItemByIdEndpoint(ItemId), UpdatePropertiesJsonObject, GraphDriveItem, OperationName)); end; /// <summary> /// Updates a drive item's properties (name, description, etc.) by path. /// </summary> /// <param name="ItemPath">Path to the item (e.g., 'Documents/file.docx').</param> /// <param name="UpdatePropertiesJsonObject">JSON object containing the properties to update.</param> /// <param name="GraphDriveItem">Record to store the updated item details. If it already contains an item with the same ID, that item is refreshed.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure UpdateDriveItemByPath(ItemPath: Text; UpdatePropertiesJsonObject: JsonObject; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" begin exit(UpdateDriveItemByPath(ItemPath, UpdatePropertiesJsonObject, GraphDriveItem, 'UpdateDriveItemByPath')); end; local procedure UpdateDriveItemByPath(ItemPath: Text; UpdatePropertiesJsonObject: JsonObject; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary; OperationName: Text): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; begin EnsureInitialized(); EnsureSiteId(); EnsureDefaultDriveId(); SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); if ItemPath = '' then begin SharePointGraphResponse.SetError(InvalidItemPathErr); Session.LogMessage('0000UKP', InvalidItemPathErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl, 'OperationName', OperationName); exit(SharePointGraphResponse); end; if UpdatePropertiesJsonObject.Keys().Count() = 0 then begin SharePointGraphResponse.SetError(InvalidUpdateBodyErr); Session.LogMessage('0000UKQ', InvalidUpdateBodyErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl, 'OperationName', OperationName); exit(SharePointGraphResponse); end; exit(UpdateDriveItemAtEndpoint(SharePointGraphUriBuilder.GetDriveItemByPathEndpoint(ItemPath), UpdatePropertiesJsonObject, GraphDriveItem, OperationName)); end; local procedure UpdateDriveItemAtEndpoint(Endpoint: Text; UpdatePropertiesJsonObject: JsonObject; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary; OperationName: Text): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; ResponseJson: JsonObject; ErrorMessage: Text; begin SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); if not SharePointGraphRequestHelper.Patch(Endpoint, UpdatePropertiesJsonObject, ResponseJson) then begin ErrorMessage := StrSubstNo(FailedToUpdateDriveItemErr, SharePointGraphRequestHelper.GetDiagnostics().GetResponseReasonPhrase()); SharePointGraphResponse.SetError(ErrorMessage); Session.LogMessage('0000UKR', ErrorMessage, Verbosity::Error, DataClassification::CustomerContent, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl, 'OperationName', OperationName); exit(SharePointGraphResponse); end; GraphDriveItem.Init(); GraphDriveItem.DriveId := CopyStr(DefaultDriveId, 1, MaxStrLen(GraphDriveItem.DriveId)); if not SharePointGraphParser.ParseDriveItemDetail(ResponseJson, GraphDriveItem) then begin SharePointGraphResponse.SetError(FailedToParseUpdatedDriveItemErr); Session.LogMessage('0000UKS', FailedToParseUpdatedDriveItemErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl, 'OperationName', OperationName); exit(SharePointGraphResponse); end; if not GraphDriveItem.Insert() then GraphDriveItem.Modify(); SharePointGraphResponse.SetSuccess(); Session.LogMessage('0000UKT', StrSubstNo(OperationSuccessTelemetryMsg, OperationName), Verbosity::Normal, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl, 'OperationName', OperationName); exit(SharePointGraphResponse); end; /// <summary> /// Renames a drive item by ID. /// </summary> /// <param name="ItemId">ID of the item to rename.</param> /// <param name="NewName">New name for the item.</param> /// <param name="GraphDriveItem">Record to store the updated item details. If it already contains an item with the same ID, that item is refreshed.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure RenameDriveItem(ItemId: Text; NewName: Text; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; RequestJsonObj: JsonObject; begin EnsureInitialized(); if NewName = '' then begin SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); SharePointGraphResponse.SetError(InvalidNewNameErr); Session.LogMessage('0000UKU', InvalidNewNameErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; RequestJsonObj.Add('name', NewName); exit(UpdateDriveItem(ItemId, RequestJsonObj, GraphDriveItem, 'RenameDriveItem')); end; /// <summary> /// Renames a drive item by path. /// </summary> /// <param name="ItemPath">Path to the item (e.g., 'Documents/file.docx').</param> /// <param name="NewName">New name for the item.</param> /// <param name="GraphDriveItem">Record to store the updated item details. If it already contains an item with the same ID, that item is refreshed.</param> /// <returns>An operation response object containing the result of the operation.</returns> procedure RenameDriveItemByPath(ItemPath: Text; NewName: Text; var GraphDriveItem: Record "SharePoint Graph Drive Item" temporary): Codeunit "SharePoint Graph Response" var SharePointGraphResponse: Codeunit "SharePoint Graph Response"; RequestJsonObj: JsonObject; begin EnsureInitialized(); if NewName = '' then begin SharePointGraphResponse.SetRequestHelper(SharePointGraphRequestHelper); SharePointGraphResponse.SetError(InvalidNewNameErr); Session.LogMessage('0000UKV', InvalidNewNameErr, Verbosity::Error, DataClassification::SystemMetadata, TelemetryScope::ExtensionPublisher, 'Category', GraphSharePointCategoryLbl); exit(SharePointGraphResponse); end; RequestJsonObj.Add('name', NewName); exit(UpdateDriveItemByPath(ItemPath, RequestJsonObj, GraphDriveItem, 'RenameDriveItemByPath')); end; #endregion /// <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(SharePointGraphRequestHelper.GetDiagnostics()); end; /// <summary> /// Sets the site ID directly for testing purposes. /// </summary> /// <param name="NewSiteId">The site ID to set.</param> internal procedure SetSiteIdForTesting(NewSiteId: Text) begin SiteId := NewSiteId; SharePointGraphUriBuilder.Initialize(SiteId, SharePointGraphRequestHelper); end; /// <summary> /// Sets the default drive ID directly for testing purposes. /// </summary> /// <param name="NewDefaultDriveId">The default drive ID to set.</param> internal procedure SetDefaultDriveIdForTesting(NewDefaultDriveId: Text) begin DefaultDriveId := NewDefaultDriveId; end; // Add this method to lazily load the default drive ID local procedure EnsureDefaultDriveId() begin if DefaultDriveId = '' then GetDefaultDriveId(); end; // Add method to lazily load the site ID local procedure EnsureSiteId() begin if SiteId = '' then begin GetSiteIdFromUrl(SharePointUrl); SharePointGraphUriBuilder.Initialize(SiteId, SharePointGraphRequestHelper); end; end;}