Handler class

In the previous code you can see I’m creating first a handler class called invHandler and then calling a method from that class, here is the code for the handler class:

using Microsoft.Xrm.Sdk;
using System;
using System.Collections.Generic;
using System.Linq;
using Newtonsoft.Json.Linq;
using Core.Helpers;
using System.Globalization;
using System.Threading.Tasks;
 
public class HandlerClasss
{
    private readonly ITracingService _tracingService;
    private readonly IOrganizationService _service;
 
    public HandlerClasss(ITracingService tracingService, IOrganizationService service)
    {
        _tracingService = tracingService;
        _service = service;
    }
 
    public async Task ProcessCustomTableJsonAsync(string jsonString, string tenantId, string clientId, string clientSecret, string siteId, string libraryName, string uploadFolderPath, string fileName, IPluginExecutionContext context)
    {
        _tracingService.Trace(“Start ProcessCustomTableJson”);
 
        try
        {
            // Parse the input JSON string
            JArray CustomTables = JArray.Parse(jsonString);
 
            // Loop through each CustomTable object and make changes
            foreach (JObject CustomTable in CustomTables)
            {
                // Get a child related record
                Entity childRelatedRecord = getLastChildRelatedRecord(CustomTable);
                // Rename columns
                RenameProperty(CustomTable, “name”, “INVNR”);
                RenameProperty(CustomTable, “serialnumber”, “CONEXT”);
                RenameProperty(CustomTable, “contract.lessornumber”, “NR LO”);
                RenameProperty(CustomTable, “account.accountnumber”, “NRREL”);
                RenameProperty(CustomTable, “contract.area”, “AREA”);
 
                // Add new columns
                CustomTable[“NRCN”] = CustomTable[“contract.name”].ToString().Substring(3); // Subtract first 3 chars from INVNR
                CustomTable[“DLVVD1”] = DateTime.UtcNow.AddDays(19).ToString(“dd-MMM-yyyy”, CultureInfo.InvariantCulture); // Current date + 19 days
                CustomTable[“DLVVD2”] = childRelatedRecord.Id != Guid.Empty ? childRelatedRecord.GetAttributeValue<DateTime>(“zvbegin”).ToString(“dd-MMM-yyyy”, CultureInfo.InvariantCulture) : “”;
                CustomTable[“DTFROM”] = childRelatedRecord.Id != Guid.Empty ? childRelatedRecord.GetAttributeValue<DateTime>(“zvbegin”).ToString(“dd-MMM-yyyy”, CultureInfo.InvariantCulture) : “”;
                CustomTable[“DTTO”] = childRelatedRecord.Id != Guid.Empty ? childRelatedRecord.GetAttributeValue<DateTime>(“cwserbegin”).ToString(“dd-MMM-yyyy”, CultureInfo.InvariantCulture) : “”;
 
                // Handle conditional PAY-METH
                CustomTable[“PAY-METH”] = CustomTable[“contract.paymentmethod”]?.ToString() == “Lastschrift” ? “1” : “0”;
 
                // Handle Kundennummer
                if (CustomTable[“NRREL”] != null && CustomTable[“NR LO”] != null)
                {
                    long accountNumber = long.Parse(CustomTable[“NRREL”].ToString());
                    long lessorNumber = long.Parse(CustomTable[“NR LO”].ToString());
                    CustomTable[“Kundennummer Kurz”] = (accountNumber – (lessorNumber * 10000000)).ToString();
                }
 
                CustomTable[“ZV_BEGINN”] = childRelatedRecord.Id != Guid.Empty ? childRelatedRecord.GetAttributeValue<DateTime>(“zvbegin”).ToString(“dd-MMM-yyyy”, CultureInfo.InvariantCulture) : “”;
            }
 
            var sharePointHandler = new SharePointHandler(_tracingService);
 
            await sharePointHandler.UploadCsvFileAsync(CustomTables, tenantId, clientId, clientSecret, siteId, libraryName, uploadFolderPath, fileName);
 
            context.OutputParameters[“CustomTableGenerateCSVFile_message”] = “ok”;
        }
        catch (Exception ex)
        {
            context.OutputParameters[“CustomTableGenerateCSVFile_message”] = ex.Message;
        }
 
        _tracingService.Trace(“End ProcessCustomTableJson”);
    }
 
    public async Task UploadCsvFileAsync(JArray modifiedJson, string tenantId, string clientId, string clientSecret, string siteId, string libraryName, string uploadFolderPath, string fileName)
    {
        _tracingService.Trace(“Start UploadCsvFileAsync”);
 
        // Ensure graphClient is declared here and is available in the current context
        GraphServiceClient graphClient;
 
        try
        {
            // Authenticate using Azure Identity
            var credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
            graphClient = new GraphServiceClient(credential);
 
            // Step 1: Generate CSV from modified JSON
            byte[] newFileBytes = GenerateCsvFromJson(modifiedJson);
 
            // Step 2: Get the SharePoint document library (drive)
            var drives = await graphClient.Sites[siteId].Drives.GetAsync();
            var drive = drives.Value.FirstOrDefault(d => d.Name.Equals(libraryName, StringComparison.OrdinalIgnoreCase));
 
            if (drive == null)
            {
                throw new Exception($”Document library ‘{libraryName}’ not found.”);
            }
 
            byte[] existingFileBytes = null;
            bool fileExists = false;
 
            // Step 3: List items in the folder and check if the file exists
            try
            {
                var folderItems = await graphClient.Drives[drive.Id]
                    .Root
                    .ItemWithPath(uploadFolderPath)
                    .Children
                    .GetAsync();
 
                // Check if the file exists in the folder
                fileExists = folderItems.Value.Any(item => item.Name.Equals(fileName, StringComparison.OrdinalIgnoreCase));
            }
            catch (ServiceException ex)
            {
                _tracingService.Trace(“Error retrieving folder items: “ + ex.Message);
                throw new InvalidPluginExecutionException(“An error occurred while retrieving folder items.”);
            }
 
            // Step 4: If the file exists, download its content
            if (fileExists)
            {
                try
                {
                    var existingStream = await graphClient.Drives[drive.Id]
                        .Root
                        .ItemWithPath($”{uploadFolderPath}/{fileName}”)
                        .Content
                        .GetAsync();
 
                    using (var memoryStream = new MemoryStream())
                    {
                        existingStream.CopyTo(memoryStream);
                        existingFileBytes = memoryStream.ToArray();
                    }
                }
                catch (Exception ex)
                {
                    _tracingService.Trace($”Error downloading the file content: {ex.Message}”);
                    throw;
                }
            }
 
            // Step 5: Combine the existing content with the new content if file exists
            byte[] combinedFileBytes;
            if (existingFileBytes != null)
            {
                combinedFileBytes = CombineCsvFiles(existingFileBytes, newFileBytes);
            }
            else
            {
                // If the file doesn’t exist, use the new CSV content directly
                combinedFileBytes = newFileBytes;
            }
 
            // Step 6: Upload the combined CSV file back to SharePoint
            using (var uploadStream = new MemoryStream(combinedFileBytes))
            {
                await graphClient.Drives[drive.Id]
                    .Root
                    .ItemWithPath($”{uploadFolderPath}/{fileName}”)
                    .Content
                    .PutAsync(uploadStream);
            }
 
            Console.WriteLine(“File uploaded successfully.”);
        }
        catch (Exception ex)
        {
            _tracingService.Trace(“Error in UploadCsvFileAsync: “ + ex.Message);
            throw new InvalidPluginExecutionException(“An error occurred in UploadCsvFileAsync: “ + ex.Message);
        }
    }
 
    // Helper method to convert modified JSON to CSV
    private byte[] GenerateCsvFromJson(JArray modifiedJson)
    {
        var csvBuilder = new StringBuilder();
 
        // Add header (assuming each object has the same keys)
        var headers = modifiedJson.FirstOrDefault()?.ToObject<JObject>()?.Properties().Select(p => p.Name).ToArray();
        if (headers != null)
        {
            csvBuilder.AppendLine(string.Join(“,”, headers));
        }
 
        // Add data rows
        foreach (JObject obj in modifiedJson)
        {
            var values = obj.Properties().Select(p => p.Value.ToString()).ToArray();
            csvBuilder.AppendLine(string.Join(“,”, values));
        }
 
        // Convert CSV string to bytes
        return Encoding.UTF8.GetBytes(csvBuilder.ToString());
    }
 
    // Helper method to combine two CSV byte arrays (existing content + new content)
    private byte[] CombineCsvFiles(byte[] existingFile, byte[] newFile)
    {
        using (var memoryStream = new MemoryStream())
        {
            // Write the existing file content to memoryStream
            memoryStream.Write(existingFile, 0, existingFile.Length);
 
            // Skip the headers in the new file (assuming the first row is headers)
            string newCsvContent = Encoding.UTF8.GetString(newFile);
            var newCsvLines = newCsvContent.Split(new[] { ‘\r‘, ‘\n‘ }, StringSplitOptions.RemoveEmptyEntries).Skip(1);
            var newCsvWithoutHeader = string.Join(“\r\n“, newCsvLines);
 
            // Append new content to existing content
            byte[] newContentBytes = Encoding.UTF8.GetBytes(newCsvWithoutHeader);
            memoryStream.Write(newContentBytes, 0, newContentBytes.Length);
 
            // Return the combined file content as byte array
            return memoryStream.ToArray();
        }
    }
}

The ProcessCustomTableJsonAsync method is the one being called from the Custom API. This method is in charge of creating all the columns and rows of the file. now the code that has this method is specific to the requirement that I had. Hence the retrieval of the last created record from a related table, I am also renaming some columns, hence I am using the RenameProperty method.

Finally I am adding new columns to the file, some of them have mathematical operations and some of them have the same value in each row.

So keep in mind that you will have to change this method for your requirement.