Table 5062 Attachment, source in 29
Source29
src/Layers/W1/BaseApp/CRM/Interaction/Attachment.Table.al864 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 Microsoft.CRM.Interaction;
using Microsoft.CRM.Segment;
using Microsoft.CRM.Setup;
using Microsoft.Foundation.NoSeries;
using Microsoft.Foundation.Reporting;
using System.Environment;
using System.IO;
using System.Utilities;
table 5062 Attachment
{
Caption = 'Attachment';
DataClassification = CustomerContent;
fields
{
field(1; "No."; Integer)
{
Caption = 'No.';
NotBlank = true;
}
field(2; "Attachment File"; BLOB)
{
Caption = 'Attachment File';
}
field(3; "Storage Type"; Enum "Attachment Storage Type")
{
Caption = 'Storage Type';
}
field(4; "Storage Pointer"; Text[250])
{
Caption = 'Storage Pointer';
}
field(5; "File Extension"; Text[250])
{
Caption = 'File Extension';
}
field(6; "Read Only"; Boolean)
{
Caption = 'Read Only';
}
field(7; "Last Date Modified"; Date)
{
Caption = 'Last Date Modified';
}
field(8; "Last Time Modified"; Time)
{
Caption = 'Last Time Modified';
}
field(13; "Merge Source"; BLOB)
{
Caption = 'Merge Source';
}
field(14; "Email Message ID"; BLOB)
{
Caption = 'Email Message ID';
}
field(15; "Email Entry ID"; BLOB)
{
Caption = 'Email Entry ID';
}
field(16; "Email Message Checksum"; Integer)
{
Caption = 'Email Message Checksum';
}
field(17; "Email Message Url"; BLOB)
{
Caption = 'Email Message Url';
}
}
keys
{
key(Key1; "No.")
{
Clustered = true;
}
key(Key2; "Email Message Checksum")
{
}
}
fieldgroups
{
}
trigger OnInsert()
var
Attachment2: Record Attachment;
NextAttachmentNo: Integer;
begin
"Last Date Modified" := Today;
"Last Time Modified" := Time;
Attachment2.LockTable();
if Attachment2.FindLast() then
NextAttachmentNo := Attachment2."No." + 1
else
NextAttachmentNo := 1;
"No." := NextAttachmentNo;
RMSetup.Get();
"Storage Type" := RMSetup."Attachment Storage Type";
if "Storage Type" = "Storage Type"::"Disk File" then begin
RMSetup.TestField("Attachment Storage Location");
"Storage Pointer" := RMSetup."Attachment Storage Location";
end;
end;
trigger OnModify()
begin
"Last Date Modified" := Today;
"Last Time Modified" := Time;
end;
var
RMSetup: Record "Marketing Setup";
FileManagement: Codeunit "File Management";
AttachmentManagement: Codeunit AttachmentManagement;
ClientTypeManagement: Codeunit "Client Type Management";
#pragma warning disable AA0074
Text002: Label 'The attachment is empty.';
Text005: Label 'Export Attachment';
Text006: Label 'Import Attachment';
Text007: Label 'All Files (*.*)|*.*';
#pragma warning disable AA0470
Text008: Label 'Error during copying file: %1.';
Text009: Label 'Do you want to remove %1?';
#pragma warning restore AA0470
Text010: Label 'External file could not be removed.';
#pragma warning restore AA0074
AttachmentImportQst: Label 'Do you want to import attachment?';
AttachmentExportQst: Label 'Do you want to export attachment to view or edit it externaly?';
procedure OpenAttachment(Caption: Text[260]; IsTemporary: Boolean; LanguageCode: Code[10])
var
SegmentLine: Record "Segment Line";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeOpenAttachment(Rec, Caption, IsTemporary, LanguageCode, IsHandled);
if IsHandled then
exit;
if IsHTML() then begin
SegmentLine.Init();
SegmentLine."Language Code" := LanguageCode;
SegmentLine.Date := WorkDate();
PreviewHTMLContent(SegmentLine);
exit;
end;
if "Storage Type" = "Storage Type"::Embedded then begin
CalcFields("Attachment File");
if not "Attachment File".HasValue() then
Error(Text002);
end;
if ClientTypeManagement.GetCurrentClientType() in [CLIENTTYPE::Web, CLIENTTYPE::Tablet, CLIENTTYPE::Phone, CLIENTTYPE::Desktop] then
ProcessWebAttachment(Caption + '.' + "File Extension")
end;
procedure OpenAttachment(var SegmentLine: Record "Segment Line"; WordCaption: Text)
begin
if IsHTML() then begin
PreviewHTMLContent(SegmentLine);
exit;
end;
if "Storage Type" = "Storage Type"::Embedded then
CalcFields("Attachment File");
if SegmentLine."Word Template Code" = '' then
ProcessWebAttachment(WordCaption + '.' + "File Extension");
end;
[InherentPermissions(PermissionObjectType::TableData, Database::Attachment, 'r')]
procedure InsertRecord()
var
SequenceNoMgt: Codeunit "Sequence No. Mgt.";
begin
if not Insert() then begin
SequenceNoMgt.RebaseSeqNo(DATABASE::Attachment);
"No." := SequenceNoMgt.GetNextSeqNo(DATABASE::Attachment);
Insert();
end;
end;
procedure ShowAttachment(var SegLine: Record "Segment Line"; WordCaption: Text)
var
WordTemplateInteractions: Codeunit "Word Template Interactions";
IsHandled: Boolean;
begin
OnBeforeShowAttachment(SegLine, WordCaption, IsHandled, Rec);
if IsHandled then
exit;
if IsHTML() then begin
PreviewHTMLContent(SegLine);
exit;
end;
if "Storage Type" = "Storage Type"::Embedded then
CalcFields("Attachment File");
OnShowAttachmentOnAfterCalcAttachmentFile(Rec);
if WordTemplateInteractions.IsWordDocumentExtension("File Extension") then
WordTemplateInteractions.RunMergedDocument(SegLine, Rec)
else
ProcessWebAttachment(WordCaption + '.' + "File Extension");
end;
local procedure PreviewHTMLContent(SegmentLine: Record "Segment Line")
var
ContentPreview: Page "Content Preview";
begin
ContentPreview.SetContent(AttachmentManagement.LoadHTMLContent(Rec, SegmentLine));
ContentPreview.RunModal();
end;
[Scope('OnPrem')]
procedure ExportAttachmentToClientFile(var ExportToFile: Text): Boolean
var
FileFilter: Text;
ServerFileName: Text;
Path: Text;
Success: Boolean;
begin
RMSetup.Get();
if RMSetup."Attachment Storage Type" = RMSetup."Attachment Storage Type"::"Disk File" then
RMSetup.TestField("Attachment Storage Location");
ServerFileName := FileManagement.ServerTempFileName("File Extension");
ExportAttachmentToServerFile(ServerFileName);
Path := FileManagement.Magicpath();
if ExportToFile = '' then
Path := '';
FileFilter := UpperCase("File Extension") + ' (*.' + "File Extension" + ')|*.' + "File Extension";
Success := Download(ServerFileName, Text005, Path, FileFilter, ExportToFile);
FileManagement.DeleteServerFile(ServerFileName);
exit(Success);
end;
[Scope('OnPrem')]
procedure ImportAttachmentFromClientFile(ImportFromFile: Text; IsTemporary: Boolean; IsInherited: Boolean): Boolean
var
FileName: Text;
ServerFileName: Text;
NewAttachmentNo: Integer;
begin
ClearLastError();
if IsTemporary then
exit(ImportTemporaryAttachmentFromClientFile(ImportFromFile));
TestField("Read Only", false);
RMSetup.Get();
if RMSetup."Attachment Storage Type" = RMSetup."Attachment Storage Type"::"Disk File" then
RMSetup.TestField("Attachment Storage Location");
if IsInherited then begin
NewAttachmentNo := AttachmentManagement.InsertAttachment("No.");
Get(NewAttachmentNo);
end else
if "No." = 0 then
NewAttachmentNo := AttachmentManagement.InsertAttachment(0)
else
NewAttachmentNo := "No.";
Get(NewAttachmentNo);
// passing to UPLOAD function when only server path is specified, not ALSO the file name,
// then function updates the server file path with the actual client name
ServerFileName := TemporaryPath;
FileName := ImportFromFile;
if not Upload(Text006, '', Text007, FileName, ServerFileName) then begin
if GetLastErrorText <> '' then
Error(Text008, GetLastErrorText);
exit(false);
end;
exit(ImportAttachmentFromServerFile(ServerFileName, false, true));
end;
local procedure ImportTemporaryAttachmentFromClientFile(ImportFromFile: Text): Boolean
var
TempBlob: Codeunit "Temp Blob";
FileName: Text;
begin
FileName := FileManagement.BLOBImport(TempBlob, ImportFromFile);
if FileName <> '' then begin
SetAttachmentFileFromBlob(TempBlob);
"Storage Type" := "Storage Type"::Embedded;
"Storage Pointer" := '';
"File Extension" := CopyStr(UpperCase(FileManagement.GetExtension(FileName)), 1, 250);
Modify();
exit(true);
end;
exit(false);
end;
[Scope('OnPrem')]
procedure ExportAttachmentToServerFile(var ExportToFile: Text) Result: Boolean
var
TempBlob: Codeunit "Temp Blob";
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeExportAttachmentToServerFile(Rec, ExportToFile, Result, IsHandled);
if IsHandled then
exit(Result);
// This function assumes that CALCFIELDS on the attachment field has been called before
RMSetup.Get();
if RMSetup."Attachment Storage Type" = RMSetup."Attachment Storage Type"::"Disk File" then
RMSetup.TestField("Attachment Storage Location");
case "Storage Type" of
"Storage Type"::Embedded:
begin
if "Attachment File".HasValue() then begin
TempBlob.FromRecord(Rec, FieldNo("Attachment File"));
if ExportToFile = '' then
ExportToFile := FileManagement.ServerTempFileName("File Extension");
FileManagement.BLOBExportToServerFile(TempBlob, ExportToFile); // export BLOB to file on server (UNC location also)
exit(true);
end;
exit(false);
end;
"Storage Type"::"Disk File":
begin
if ExportToFile = '' then
ExportToFile := TemporaryPath + FileManagement.GetFileName(ConstDiskFileName());
FileManagement.CopyServerFile(GetServerFileName(ConstDiskFileName()), ExportToFile, false); // Copy from server location to another location (UNC location also)
exit(true);
end;
end;
exit(false);
end;
/// <summary>
/// Export the Attachment to the TempBlob Codeunit.
/// </summary>
/// <param name="TempBlob"></param>
/// <returns>true if a value attachment is return in the TempBlob parameter; otherwise false</returns>
procedure ExportAttachmentToTempBlob(var TempBlob: Codeunit "Temp Blob") Result: Boolean
begin
RMSetup.Get();
if RMSetup."Attachment Storage Type" = RMSetup."Attachment Storage Type"::"Disk File" then
RMSetup.TestField("Attachment Storage Location");
case "Storage Type" of
"Storage Type"::Embedded:
begin
if "Attachment File".HasValue() then begin
TempBlob.FromRecord(Rec, FieldNo("Attachment File"));
exit(true);
end;
exit(false);
end;
"Storage Type"::"Disk File":
begin
FileManagement.BLOBImportFromServerFile(TempBlob, GetServerFileName(ConstDiskFileName()));
exit(true);
end;
end;
exit(false);
end;
[Scope('OnPrem')]
procedure ImportAttachmentFromServerFile(ImportFromFile: Text; IsTemporary: Boolean; Overwrite: Boolean) Result: Boolean
var
TempBlob: Codeunit "Temp Blob";
FileExt: Text[250];
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeImportAttachmentFromServerFile(Rec, ImportFromFile, Result, IsTemporary, Overwrite, IsHandled);
if IsHandled then
exit(Result);
if IsTemporary then begin
ImportTemporaryAttachmentFromServerFile(ImportFromFile);
exit(true);
end;
if not Overwrite then
TestField("Read Only", false);
RMSetup.Get();
if RMSetup."Attachment Storage Type" = RMSetup."Attachment Storage Type"::"Disk File" then
RMSetup.TestField("Attachment Storage Location");
case RMSetup."Attachment Storage Type" of
RMSetup."Attachment Storage Type"::Embedded:
begin
FileManagement.BLOBImportFromServerFile(TempBlob, ImportFromFile); // Copy from file on server (UNC location also)
SetAttachmentFileFromBlob(TempBlob);
"Storage Type" := "Storage Type"::Embedded;
"Storage Pointer" := '';
FileExt := CopyStr(FileManagement.GetExtension(ImportFromFile), 1, 250);
if FileExt <> '' then
"File Extension" := FileExt;
Modify(true);
exit(true);
end;
"Storage Type"::"Disk File":
begin
"Storage Type" := "Storage Type"::"Disk File";
"Storage Pointer" := RMSetup."Attachment Storage Location";
FileExt := CopyStr(FileManagement.GetExtension(ImportFromFile), 1, 250);
if FileExt <> '' then
"File Extension" := FileExt;
FileManagement.CopyServerFile(ImportFromFile, ConstDiskFileName(), Overwrite); // Copy from UNC location to another UNC location
Modify(true);
exit(true);
end;
end;
exit(false);
end;
internal procedure ImportAttachmentFromStream(InStream: InStream; FileExtension: Text) NewattachmentNo: Integer
begin
SetAttachmentFileFromStream(InStream);
"Storage Type" := "Storage Type"::Embedded;
"Storage Pointer" := '';
"File Extension" := CopyStr(FileExtension, 1, 250);
Insert(true);
NewattachmentNo := "No.";
end;
local procedure ImportTemporaryAttachmentFromServerFile(ImportFromFile: Text)
var
TempBlob: Codeunit "Temp Blob";
begin
FileManagement.BLOBImportFromServerFile(TempBlob, ImportFromFile);
SetAttachmentFileFromBlob(TempBlob);
"Storage Type" := "Storage Type"::Embedded;
"Storage Pointer" := '';
"File Extension" := CopyStr(UpperCase(FileManagement.GetExtension(ImportFromFile)), 1, 250);
end;
[Scope('OnPrem')]
procedure RemoveAttachment(Prompt: Boolean) DeleteOK: Boolean
var
DeleteYesNo: Boolean;
begin
DeleteOK := false;
DeleteYesNo := true;
if Prompt then
if not Confirm(
Text009, false, TableCaption)
then
DeleteYesNo := false;
if DeleteYesNo then begin
if "Storage Type" = "Storage Type"::"Disk File" then
if not FileManagement.DeleteServerFile(ConstDiskFileName()) then
Message(Text010);
Delete(true);
DeleteOK := true;
end;
end;
[Scope('OnPrem')]
procedure WizEmbeddAttachment(FromAttachment: Record Attachment)
var
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeWizEmbeddAttachment(Rec, FromAttachment, IsHandled);
if IsHandled then
exit;
Rec := FromAttachment;
"No." := 0;
"Storage Type" := "Storage Type"::Embedded;
FromAttachment.TestField("No.");
case FromAttachment."Storage Type" of
FromAttachment."Storage Type"::"Disk File":
ImportAttachmentFromServerFile(FromAttachment.ConstDiskFileName(), true, false);
FromAttachment."Storage Type"::Embedded:
begin
FromAttachment.CalcFields("Attachment File");
if FromAttachment."Attachment File".HasValue() then
"Attachment File" := FromAttachment."Attachment File";
end;
end;
end;
procedure WizSaveAttachment()
var
Attachment2: Record Attachment;
IsHandled: Boolean;
begin
IsHandled := false;
OnBeforeWizSaveAttachment(Rec, IsHandled);
if IsHandled then
exit;
RMSetup.Get();
if RMSetup."Attachment Storage Type" = RMSetup."Attachment Storage Type"::Embedded then begin
"Storage Pointer" := '';
exit;
end;
"Storage Pointer" := RMSetup."Attachment Storage Location";
CopyAttachmentAsFile(Rec, Attachment2);
Clear(Rec);
Rec := Attachment2;
end;
procedure ConstDiskFileName() DiskFileName: Text
begin
OnBeforeConstDiskFileName(Rec, DiskFileName);
if DiskFileName = '' then
DiskFileName := "Storage Pointer" + '\' + Format("No.") + '.' + "File Extension";
end;
local procedure CopyAttachmentAsFile(var FromAttachment: Record Attachment; var ToAttachment: Record Attachment)
begin
ToAttachment."No." := FromAttachment."No.";
ToAttachment."Storage Type" := ToAttachment."Storage Type"::"Disk File";
ToAttachment."Storage Pointer" := RMSetup."Attachment Storage Location";
ToAttachment."Attachment File" := FromAttachment."Attachment File";
ToAttachment."File Extension" := FromAttachment."File Extension";
ToAttachment."Read Only" := FromAttachment."Read Only";
ToAttachment."Last Date Modified" := FromAttachment."Last Date Modified";
ToAttachment."Last Time Modified" := FromAttachment."Last Time Modified";
OnAfterCopyAttachmentAsFile(FromAttachment, ToAttachment);
end;
procedure LinkToMessage(MessageID: Text; EntryID: Text; RunTrigger: Boolean)
begin
"Storage Type" := "Storage Type"::"Exchange Storage";
"Read Only" := true;
SetMessageID(MessageID);
SetEntryID(EntryID);
Modify(RunTrigger);
end;
procedure Checksum(MessageID: Text) ChecksumValue: Integer
var
CharNo: Integer;
DecValue: Decimal;
MaxInteger: Integer;
begin
Randomize(1);
MaxInteger := 2147483647;
for CharNo := 1 to StrLen(MessageID) do
DecValue := (DecValue + (((MessageID[CharNo] mod 43) + 1) * Random((MaxInteger div 44)))) mod MaxInteger;
ChecksumValue := DecValue;
end;
procedure GetMessageID() Return: Text
var
InStream: InStream;
begin
CalcFields("Email Message ID");
"Email Message ID".CreateInStream(InStream);
InStream.ReadText(Return);
end;
procedure SetMessageID(MessageID: Text)
var
OutStream: OutStream;
begin
Clear("Email Message ID");
"Email Message ID".CreateOutStream(OutStream);
OutStream.WriteText(MessageID);
"Email Message Checksum" := Checksum(MessageID);
end;
procedure SetEntryID(EntryID: Text)
var
OutStream: OutStream;
begin
Clear("Email Entry ID");
"Email Entry ID".CreateOutStream(OutStream);
OutStream.WriteText(EntryID);
end;
procedure GetEmailMessageUrl() Return: Text
var
InStream: InStream;
begin
CalcFields("Email Message Url");
"Email Message Url".CreateInStream(InStream);
InStream.ReadText(Return);
end;
procedure SetEmailMessageUrl(Url: Text)
var
OutStream: OutStream;
begin
Clear("Email Message Url");
"Email Message Url".CreateOutStream(OutStream);
OutStream.WriteText(url);
end;
procedure Read() Result: Text
var
DataInStream: InStream;
begin
Result := '';
CalcFields("Attachment File");
if not "Attachment File".HasValue() then
exit;
"Attachment File".CreateInStream(DataInStream, TEXTENCODING::UTF8);
DataInStream.Read(Result);
end;
procedure Write(SourceText: Text)
var
DataOutStream: OutStream;
begin
"Attachment File".CreateOutStream(DataOutStream, TEXTENCODING::UTF8);
DataOutStream.Write(SourceText);
end;
procedure ReadHTMLCustomLayoutAttachment(var ContentBodyText: Text; var CustomLayoutCode: Code[20]): Boolean
var
ReportLayoutName: Text[250];
begin
exit(ReadHTMLCustomLayoutAttachment(ContentBodyText, CustomLayoutCode, ReportLayoutName));
end;
procedure ReadHTMLCustomLayoutAttachment(var ContentBodyText: Text; var CustomLayoutCode: Code[20]; var ReportLayoutName: Text[250]): Boolean
var
DataText: Text;
begin
DataText := Read();
if (DataText[1] = '<') and (StrPos(DataText, '>') > 1) then
exit(ParseHTMLCustomLayoutAttachment(DataText, ContentBodyText, ReportLayoutName))
else
exit(ParseHTMLCustomLayoutAttachment(DataText, ContentBodyText, CustomLayoutCode));
end;
procedure WriteHTMLCustomLayoutAttachment(ContentBodyText: Text; CustomLayoutCode: Code[20])
var
DataText: Text;
begin
DataText := PadStr('', GetCustomLayoutCodeLength() - StrLen(CustomLayoutCode), '0') + CustomLayoutCode;
DataText += ContentBodyText;
Write(DataText);
Modify();
end;
procedure WriteHTMLCustomLayoutAttachment(ContentBodyText: Text; ReportLayoutName: Text[250])
begin
Write('<' + ReportLayoutName + '>' + ContentBodyText);
Modify();
end;
local procedure ParseHTMLCustomLayoutAttachment(DataText: Text; var ContentBodyText: Text; var CustomLayoutCode: Code[20]): Boolean
var
TotalLength: Integer;
LayoutIDLength: Integer;
begin
LayoutIDLength := GetCustomLayoutCodeLength();
TotalLength := StrLen(DataText);
if TotalLength < LayoutIDLength then
exit(false);
if DataText = '' then
exit;
CustomLayoutCode := DelChr(CopyStr(DataText, 1, LayoutIDLength), '<', '0');
if CustomLayoutCode = '' then
exit;
if TotalLength = LayoutIDLength then
ContentBodyText := ''
else
ContentBodyText := CopyStr(DataText, LayoutIDLength + 1, TotalLength - LayoutIDLength);
exit(true);
end;
local procedure ParseHTMLCustomLayoutAttachment(DataText: Text; var ContentBodyText: Text; var LayoutName: Text[250]): Boolean
var
i: Integer;
begin
if DataText = '' then
exit(false);
if DataText[1] <> '<' then
exit(false);
i := StrPos(DataText, '>');
if i < 2 then
exit(false);
LayoutName := CopyStr(CopyStr(DataText, 2, i - 2), 1, MaxStrLen(LayoutName));
if StrLen(DataText) < i + 1 then
ContentBodyText := ''
else
ContentBodyText := CopyStr(DataText, i + 1);
exit(true);
end;
procedure IsHTML(): Boolean
begin
exit(LowerCase("File Extension") = 'html');
end;
procedure IsHTMLReady(): Boolean
var
DataText: Text;
DataLength: Integer;
HTMLMask: Text;
HTMLMaskLength: Integer;
begin
if not IsHTML() then
exit(false);
HTMLMask := '<html>';
HTMLMaskLength := StrLen(HTMLMask);
DataText := Read();
DataLength := StrLen(DataText);
if DataLength < HTMLMaskLength then
exit(false);
exit(LowerCase(CopyStr(DataText, 1, HTMLMaskLength)) = HTMLMask);
end;
procedure IsHTMLCustomLayout(): Boolean
var
DataText: Text;
DataLength: Integer;
CustomLayoutIDLength: Integer;
CustomLayoutCode: Code[20];
begin
CustomLayoutIDLength := GetCustomLayoutCodeLength();
if not IsHTML() then
exit(false);
DataText := Read();
if DataText = '' then
exit(false);
DataLength := StrLen(DataText);
// Is it a built-in layout name?
if (DataLength > 6) and (DataText[1] = '<') and (DataText[DataLength] = '>') then
exit(true);
// Is it a custom layout code?
if DataLength < CustomLayoutIDLength then
exit(false);
CustomLayoutCode := DelChr(DataText, '<', '0');
exit(CustomLayoutCode <> '');
end;
local procedure GetCustomLayoutCodeLength(): Integer
var
DummyCustomReportLayout: Record "Custom Report Layout";
begin
exit(MaxStrLen(DummyCustomReportLayout.Code));
end;
local procedure ProcessWebAttachment(FileName: Text)
var
TempBlob: Codeunit "Temp Blob";
begin
if Confirm(AttachmentExportQst, true) then begin
TempBlob.FromRecord(Rec, FieldNo("Attachment File"));
FileManagement.BLOBExport(TempBlob, FileName, true);
if not "Read Only" then
if Confirm(AttachmentImportQst, true) then
ImportAttachmentFromClientFile('', IsTemporary, false);
end
end;
procedure GetServerFileName(DiskFileName: Text): Text
begin
if not Exists(DiskFileName) then
DiskFileName := DelChr(DiskFileName, '>', '.' + "File Extension");
exit(DiskFileName);
end;
procedure SetAttachmentFileFromBlob(TempBlob: Codeunit "Temp Blob")
var
RecordRef: RecordRef;
begin
RecordRef.GetTable(Rec);
TempBlob.ToRecordRef(RecordRef, FieldNo("Attachment File"));
RecordRef.SetTable(Rec);
end;
internal procedure SetAttachmentFileFromStream(InStream: InStream)
var
OutStream: OutStream;
begin
Rec."Attachment File".CreateOutStream(OutStream);
CopyStream(OutStream, InStream);
end;
[IntegrationEvent(false, false)]
local procedure OnAfterCopyAttachmentAsFile(var FromAttachment: Record Attachment; var ToAttachment: Record Attachment)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeShowAttachment(var SegLine: Record "Segment Line"; WordCaption: Text; var IsHandled: Boolean; var Attachment: Record Attachment)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeExportAttachmentToServerFile(var Attachment: Record Attachment; ExportToFile: Text; var Result: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeImportAttachmentFromServerFile(var Attachment: Record Attachment; ImportFromFile: Text; var Result: Boolean; IsTemporary: Boolean; Overwrite: Boolean; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnShowAttachmentOnAfterCalcAttachmentFile(var Attachment: Record Attachment)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeOpenAttachment(var Attachment: Record Attachment; var Caption: Text[260]; IsTemporary: Boolean; LanguageCode: Code[10]; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeWizSaveAttachment(var Attachment: Record Attachment; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeWizEmbeddAttachment(var Attachment: Record Attachment; FromAttachment: Record Attachment; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeConstDiskFileName(var Attachment: Record Attachment; var DiskFileName: Text)
begin
end;
}