Codeunit 4308 Agent Message Impl., source in 28

// ------------------------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// ------------------------------------------------------------------------------------------------

namespace System.Agents;

using System.IO;
using System.Utilities;

codeunit 4308 "Agent Message Impl."
{
    Access = Internal;
    InherentEntitlements = X;
    InherentPermissions = X;

    var
        GlobalIgnoreAttachment: Boolean;
        AttachmentsFilenameLbl: Label 'attachments_task%1_%2.zip', Comment = 'Filename format for downloading multiple attachments as a zip file. %1 = task ID, %2 = date/time stamp', Locked = true;

    procedure GetText(TaskID: BigInteger; MessageID: Guid): Text
    var
        AgentTaskMessage: Record "Agent Task Message";
    begin
        AgentTaskMessage.Get(TaskID, MessageID);
        exit(GetText(AgentTaskMessage));
    end;

    procedure GetText(var AgentTaskMessage: Record "Agent Task Message"): Text
    var
        AgentTaskImpl: Codeunit "Agent Task Impl.";
        ContentInStream: InStream;
        ContentText: Text;
    begin
        AgentTaskMessage.CalcFields(Content);
        AgentTaskMessage.Content.CreateInStream(ContentInStream, AgentTaskImpl.GetDefaultEncoding());
        ContentInStream.Read(ContentText);
        exit(ContentText);
    end;

    procedure UpdateText(TaskID: BigInteger; MessageID: Guid; NewMessageText: Text)
    var
        AgentTaskMessage: Record "Agent Task Message";
    begin
        AgentTaskMessage."Task ID" := TaskID;
        AgentTaskMessage.ID := MessageID;
        UpdateText(AgentTaskMessage, NewMessageText);
    end;

    procedure UpdateText(var AgentTaskMessage: Record "Agent Task Message"; NewMessageText: Text)
    var
        AgentTaskMessageToModify: Record "Agent Task Message";
        AgentTaskImpl: Codeunit "Agent Task Impl.";
        ContentOutStream: OutStream;
    begin
        AgentTaskMessageToModify.Get(AgentTaskMessage."Task ID", AgentTaskMessage.ID);
        AgentTaskMessageToModify.Content.CreateOutStream(ContentOutStream, AgentTaskImpl.GetDefaultEncoding());
        ContentOutStream.Write(NewMessageText);
        AgentTaskMessageToModify.Modify(true);

        AgentTaskMessage.Content := AgentTaskMessageToModify.Content;
    end;

    procedure IsEditable(TaskID: BigInteger; MessageID: Guid): Boolean
    var
        AgentTaskMessage: Record "Agent Task Message";
    begin
        AgentTaskMessage.Get(TaskID, MessageID);
        exit(IsEditable(AgentTaskMessage));
    end;

    procedure IsEditable(var AgentTaskMessage: Record "Agent Task Message"): Boolean
    begin
        if AgentTaskMessage.Type <> AgentTaskMessage.Type::Output then
            exit(false);

        exit((AgentTaskMessage.Status = AgentTaskMessage.Status::Draft) or (AgentTaskMessage.Status = AgentTaskMessage.Status::" "));
    end;

    procedure SetStatusToSent(TaskID: BigInteger; MessageID: Guid)
    var
        AgentTaskMessage: Record "Agent Task Message";
    begin
        AgentTaskMessage."Task ID" := TaskID;
        AgentTaskMessage.ID := MessageID;
        SetStatusToSent(AgentTaskMessage);
    end;

    procedure SetStatusToSent(var AgentTaskMessage: Record "Agent Task Message")
    begin
        UpdateStatus(AgentTaskMessage, AgentTaskMessage.Status::Sent);
    end;

    procedure SetIgnoreAttachment(IgnoreAttachment: Boolean)
    begin
        GlobalIgnoreAttachment := IgnoreAttachment;
    end;

    procedure AddAttachment(var AgentTaskMessage: Record "Agent Task Message"; var TempAgentTaskFile: Record "Agent Task File" temporary; IgnoredReason: Text[250])
    var
        AgentTaskImpl: Codeunit "Agent Task Impl.";
        FileInstream: InStream;
    begin
        TempAgentTaskFile.CalcFields(Content);
        if not TempAgentTaskFile.Content.HasValue() then
            exit;

        TempAgentTaskFile.Content.CreateInStream(FileInstream, AgentTaskImpl.GetDefaultEncoding());
        AddAttachment(AgentTaskMessage, TempAgentTaskFile."File Name", TempAgentTaskFile."File MIME Type", FileInstream, IgnoredReason);
    end;

    procedure AddAttachment(var AgentTaskMessage: Record "Agent Task Message"; FileName: Text[250]; FileMIMEType: Text[100]; InStream: InStream)
    begin
        AddAttachment(AgentTaskMessage, FileName, FileMIMEType, InStream, '');
    end;

    procedure AddAttachment(var AgentTaskMessage: Record "Agent Task Message"; FileName: Text[250]; FileMIMEType: Text[100]; InStream: InStream; IgnoredReason: Text[250])
    var
        AgentTaskFile: Record "Agent Task File";
        AgentTaskMessageAttachment: Record "Agent Task Message Attachment";
        AgentTaskImpl: Codeunit "Agent Task Impl.";
        OutStream: OutStream;
    begin
        // Add attachment to task file
        AgentTaskFile."Task ID" := AgentTaskMessage."Task ID";
        AgentTaskFile."File Name" := FileName;
        AgentTaskFile."File MIME Type" := FileMIMEType;
        AgentTaskFile.Content.CreateOutStream(OutStream, AgentTaskImpl.GetDefaultEncoding());
        CopyStream(OutStream, InStream);
        AgentTaskFile.Insert();

        // Link task file to task message
        AgentTaskMessageAttachment."Task ID" := AgentTaskMessage."Task ID";
        AgentTaskMessageAttachment."Message ID" := AgentTaskMessage.ID;
        AgentTaskMessageAttachment."File ID" := AgentTaskFile.ID;
        AgentTaskMessageAttachment.Ignored := GlobalIgnoreAttachment;
        AgentTaskMessageAttachment."Ignored Reason" := CopyStr(IgnoredReason, 1, MaxStrLen(AgentTaskMessageAttachment."Ignored Reason"));
        AgentTaskMessageAttachment.Insert();
    end;

    procedure DownloadAttachments(var AgentTaskMessage: Record "Agent Task Message")
    var
        AgentTaskMessageAttachment: Record "Agent Task Message Attachment";
        AgentTaskFile: Record "Agent Task File";
        DataCompression: Codeunit "Data Compression";
        TempBlob: Codeunit "Temp Blob";
        AgentTaskImpl: Codeunit "Agent Task Impl.";
        FileInStream: InStream;
        ZipOutStream: OutStream;
        ZipInStream: InStream;
        FileName: Text;
        AttachmentCount: Integer;
        DownloadDialogTitleLbl: Label 'Download Email Attachment';
    begin
        AgentTaskMessageAttachment.SetRange("Task ID", AgentTaskMessage."Task ID");
        AgentTaskMessageAttachment.SetRange("Message ID", AgentTaskMessage.ID);
        if not AgentTaskMessageAttachment.FindSet() then
            exit;

        // Count attachments
        AttachmentCount := AgentTaskMessageAttachment.Count();

        // If single file, download directly
        if AttachmentCount = 1 then begin
            ShowOrDownloadAttachment(AgentTaskMessageAttachment."Task ID", AgentTaskMessageAttachment."File ID", true);
            exit;
        end;

        // If multiple files, create a zip
        DataCompression.CreateZipArchive();
        repeat
            if AgentTaskFile.Get(AgentTaskMessageAttachment."Task ID", AgentTaskMessageAttachment."File ID") then begin
                AgentTaskFile.CalcFields(Content);
                AgentTaskFile.Content.CreateInStream(FileInStream, AgentTaskImpl.GetDefaultEncoding());
                DataCompression.AddEntry(FileInStream, AgentTaskFile."File Name");
            end;
        until AgentTaskMessageAttachment.Next() = 0;

        TempBlob.CreateOutStream(ZipOutStream);
        DataCompression.SaveZipArchive(ZipOutStream);
        DataCompression.CloseZipArchive();
        TempBlob.CreateInStream(ZipInStream);
        FileName := StrSubstNo(AttachmentsFilenameLbl, Format(AgentTaskMessage."Task ID"), Format(AgentTaskMessage.SystemCreatedAt));
        File.DownloadFromStream(ZipInStream, DownloadDialogTitleLbl, '', '', FileName);
    end;

    procedure ShowOrDownloadAttachment(TaskID: BigInteger; FileID: BigInteger; ForceDownloadAttachment: Boolean)
    var
        AgentTaskFile: Record "Agent Task File";
    begin
        if not AgentTaskFile.Get(TaskID, FileID) then
            exit;

        ShowOrDownloadAttachment(AgentTaskFile, ForceDownloadAttachment);
    end;

    procedure ShowOrDownloadAttachment(var AgentTaskFile: Record "Agent Task File"; ForceDownloadAttachment: Boolean)
    var
        AgentTaskImpl: Codeunit "Agent Task Impl.";
        InStream: InStream;
        FileName: Text;
        DownloadDialogTitleLbl: Label 'Download Email Attachment';
    begin
        FileName := AgentTaskFile."File Name";
        AgentTaskFile.CalcFields(Content);
        AgentTaskFile.Content.CreateInStream(InStream, AgentTaskImpl.GetDefaultEncoding());
        if not ForceDownloadAttachment then
            if File.ViewFromStream(InStream, FileName, false) then
                exit;

        File.DownloadFromStream(InStream, DownloadDialogTitleLbl, '', '', FileName);
    end;

    procedure GetAttachments(TaskID: BigInteger; MessageID: Guid; var TempAgentTaskFile: Record "Agent Task File" temporary)
    var
        AgentTaskMessageAttachment: Record "Agent Task Message Attachment";
        AgentTaskFile: Record "Agent Task File";
        AgentTaskFileMustBeTemporaryErr: Label 'The Agent Task File used for this procedure must be temporary.';
    begin
        if not TempAgentTaskFile.IsTemporary() then
            Error(AgentTaskFileMustBeTemporaryErr);

        if TaskID = 0 then
            exit;

        if IsNullGuid(MessageID) then
            exit;

        TempAgentTaskFile.Reset();
        TempAgentTaskFile.DeleteAll();

        AgentTaskMessageAttachment.SetRange("Task ID", TaskID);
        AgentTaskMessageAttachment.SetRange("Message ID", MessageID);
        if not AgentTaskMessageAttachment.FindSet() then
            exit;

        AgentTaskFile.SetAutoCalcFields(Content);

        repeat
            if not TempAgentTaskFile.Get(AgentTaskMessageAttachment."Task ID", AgentTaskMessageAttachment."File ID") then
                if AgentTaskFile.Get(AgentTaskMessageAttachment."Task ID", AgentTaskMessageAttachment."File ID") then begin
                    Clear(TempAgentTaskFile);
                    TempAgentTaskFile.TransferFields(AgentTaskFile, true);
                    TempAgentTaskFile.Content := AgentTaskFile.Content;
                    TempAgentTaskFile.Insert();
                end;
        until AgentTaskMessageAttachment.Next() = 0;
    end;

    local procedure UpdateStatus(var AgentTaskMessage: Record "Agent Task Message"; Status: Option)
    var
        AgentTaskMessageToModify: Record "Agent Task Message";
    begin
        AgentTaskMessageToModify.Get(AgentTaskMessage."Task ID", AgentTaskMessage.ID);
        AgentTaskMessageToModify.Status := Status;
        AgentTaskMessageToModify.Modify(true);

        AgentTaskMessage.Status := AgentTaskMessageToModify.Status;
    end;

    procedure GetFileSizeDisplayText(SizeInBytes: Decimal): Text
    var
        FileSizeConverted: Decimal;
        FileSizeUnit: Text;
        FileSizeTxt: Label '%1 %2', Comment = '%1 = File Size, %2 = Unit of measurement', Locked = true;
    begin
        FileSizeConverted := SizeInBytes / 1024; // The smallest size we show is KB
        if FileSizeConverted < 1024 then
            FileSizeUnit := 'KB'
        else begin
            FileSizeConverted := FileSizeConverted / 1024; // The largest size we show is MB
            FileSizeUnit := 'MB'
        end;
        exit(StrSubstNo(FileSizeTxt, Round(FileSizeConverted, 1, '>'), FileSizeUnit));
    end;
}