Codeunit 7018 Price UX Management, source in 29
Source29
src/Layers/W1/BaseApp/Pricing/PriceList/PriceUXManagement.Codeunit.al705 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.Pricing.PriceList;
using Microsoft.CRM.Campaign;
using Microsoft.CRM.Contact;
using Microsoft.Pricing.Asset;
using Microsoft.Pricing.Calculation;
using Microsoft.Pricing.Source;
using Microsoft.Projects.Project.Job;
using Microsoft.Purchases.Pricing;
using Microsoft.Purchases.Vendor;
using Microsoft.Sales.Customer;
using Microsoft.Sales.Pricing;
codeunit 7018 "Price UX Management"
{
var
MissingAlternateImplementationErr: Label 'You cannot setup exceptions because there is no alternate implementation.';
procedure GetFirstSourceFromFilter(var PriceListHeader: Record "Price List Header"; var PriceSource: Record "Price Source"; DefaultSourceType: Enum "Price Source Type")
var
Job: Record Job;
SourceType: Enum "Price Source Type";
SourceGroup: Enum "Price Source Group";
OpenFromJobCard: Boolean;
begin
PriceSource.InitSource();
PriceListHeader.FilterGroup(2);
if PriceListHeader.GetFilter("Source Group") <> '' then
Evaluate(SourceGroup, GetFirstFilterValue(PriceListHeader.GetFilter("Source Group")));
OpenFromJobCard := (SourceGroup = "Price Source Group"::Job)
and (PriceListHeader.GetFilter("Filter Source No.") <> '')
and (PriceListHeader.GetFilter("Source No.") = '');
if OpenFromJobCard then begin
Job.SetFilter("No.", GetFirstFilterValue(PriceListHeader.GetFilter("Filter Source No.")));
if not Job.IsEmpty() then begin
PriceSource.Validate("Source Type", SourceType::Job);
PriceSource.Validate(
"Source No.", GetFirstFilterValue(PriceListHeader.GetFilter("Filter Source No.")));
end;
end else
if PriceListHeader.GetFilter("Source Type") = '' then
PriceSource.Validate("Source Type", DefaultSourceType)
else begin
Evaluate(SourceType, GetFirstFilterValue(PriceListHeader.GetFilter("Source Type")));
PriceSource.Validate("Source Type", SourceType);
PriceSource.Validate(
"Parent Source No.", GetFirstFilterValue(PriceListHeader.GetFilter("Parent Source No.")));
PriceSource.Validate(
"Source No.", GetFirstFilterValue(PriceListHeader.GetFilter("Source No.")));
if PriceSource."Source Group" = PriceSource."Source Group"::All then
PriceSource."Source Group" := PriceListHeader."Source Group";
end;
Evaluate(PriceSource."Price Type", PriceListHeader.GetFilter("Price Type"));
PriceListHeader.FilterGroup(0);
end;
procedure IsAmountTypeFiltered(var PriceListHeader: Record "Price List Header") AmountTypeIsFiltered: Boolean;
var
Dummy: Enum "Price Amount Type";
begin
exit(IsAmountTypeFiltered(PriceListHeader, Dummy))
end;
procedure IsAmountTypeFiltered(var PriceListHeader: Record "Price List Header"; var FirstFilterValue: Enum "Price Amount Type") AmountTypeIsFiltered: Boolean;
var
AmountTypeFilterText: Text;
begin
PriceListHeader.FilterGroup(2);
AmountTypeFilterText := PriceListHeader.GetFilter("Amount Type");
PriceListHeader.FilterGroup(0);
if AmountTypeFilterText <> '' then
AmountTypeIsFiltered := Evaluate(FirstFilterValue, GetFirstFilterValue(AmountTypeFilterText));
if not AmountTypeIsFiltered then
FirstFilterValue := FirstFilterValue::Any;
end;
local procedure GetFirstFilterValue(FilterValue: Text) FirstValue: Text;
var
Pos: Integer;
begin
if FilterValue = '' then
exit('');
Pos := StrPos(FilterValue, '|');
if Pos = 0 then
FirstValue := FilterValue
else
FirstValue := CopyStr(FilterValue, 1, Pos - 1);
end;
procedure GetSupportedMethods(var TempPriceCalculationSetup: Record "Price Calculation Setup" temporary; var ImplementationsPerMethod: Dictionary of [Integer, Integer])
var
PriceCalculationSetup: Record "Price Calculation Setup";
Implementations: List of [Integer];
CurrMethod: Enum "Price Calculation Method";
begin
PriceCalculationSetup.SetCurrentKey(Method);
if PriceCalculationSetup.FindSet() then begin
repeat
if CurrMethod <> PriceCalculationSetup.Method then begin
if CurrMethod.AsInteger() <> 0 then begin
ImplementationsPerMethod.Add(CurrMethod.AsInteger(), Implementations.Count());
Clear(Implementations);
end;
CurrMethod := PriceCalculationSetup.Method;
TempPriceCalculationSetup.Validate(Method, CurrMethod);
TempPriceCalculationSetup.Insert(true);
end;
if not Implementations.Contains(PriceCalculationSetup.Implementation.AsInteger()) then
Implementations.Add(PriceCalculationSetup.Implementation.AsInteger());
until PriceCalculationSetup.Next() = 0;
ImplementationsPerMethod.Add(CurrMethod.AsInteger(), Implementations.Count());
if TempPriceCalculationSetup.FindFirst() then;
end;
end;
procedure PickImplementation(var CurrPriceCalculationSetup: Record "Price Calculation Setup")
var
PriceCalculationSetup: Record "Price Calculation Setup";
TempPriceCalculationSetup: Record "Price Calculation Setup" temporary;
PriceCalcImplementations: Page "Price Calc. Implementations";
begin
CollectAvailableImplementations(CurrPriceCalculationSetup, TempPriceCalculationSetup);
PriceCalcImplementations.SetData(TempPriceCalculationSetup);
PriceCalcImplementations.LookupMode := true;
if PriceCalcImplementations.RunModal() = Action::LookupOK then begin
PriceCalcImplementations.GetRecord(TempPriceCalculationSetup);
if CurrPriceCalculationSetup.Code <> TempPriceCalculationSetup.Code then begin
PriceCalculationSetup.Get(TempPriceCalculationSetup.Code);
PriceCalculationSetup.Validate(Default, true);
PriceCalculationSetup.Modify();
CurrPriceCalculationSetup.Delete();
CurrPriceCalculationSetup := PriceCalculationSetup;
CurrPriceCalculationSetup.Insert();
end;
end;
end;
local procedure CollectAvailableImplementations(CurrPriceCalculationSetup: Record "Price Calculation Setup"; var TempPriceCalculationSetup: Record "Price Calculation Setup" temporary)
var
PriceCalculationSetup: Record "Price Calculation Setup";
DefaultCode: Code[100];
begin
PriceCalculationSetup.SetRange("Group Id", CurrPriceCalculationSetup."Group Id");
PriceCalculationSetup.SetRange(Enabled, true);
if PriceCalculationSetup.FindSet() then begin
repeat
TempPriceCalculationSetup := PriceCalculationSetup;
TempPriceCalculationSetup.Insert();
if PriceCalculationSetup.Default then
DefaultCode := PriceCalculationSetup.Code;
until PriceCalculationSetup.Next() = 0;
if DefaultCode <> '' then
TempPriceCalculationSetup.Get(DefaultCode)
else
TempPriceCalculationSetup.FindFirst();
end;
end;
local procedure SelectJobPriceLists(var PriceListHeader: Record "Price List Header"; var PriceListCode: Code[20]) IsPicked: Boolean;
var
PurchaseJobPriceLists: Page "Purchase Job Price Lists";
SalesJobPriceLists: Page "Sales Job Price Lists";
begin
PriceListCode := '';
case PriceListHeader."Price Type" of
"Price Type"::Sale:
begin
SalesJobPriceLists.LookupMode(true);
SalesJobPriceLists.SetRecordFilter(PriceListHeader);
if SalesJobPriceLists.RunModal() = Action::LookupOK then
SalesJobPriceLists.GetRecord(PriceListHeader);
end;
"Price Type"::Purchase:
begin
PurchaseJobPriceLists.LookupMode(true);
PurchaseJobPriceLists.SetRecordFilter(PriceListHeader);
if PurchaseJobPriceLists.RunModal() = Action::LookupOK then
PurchaseJobPriceLists.GetRecord(PriceListHeader);
end;
end;
PriceListCode := PriceListHeader.Code;
IsPicked := PriceListCode <> '';
end;
local procedure SelectPriceLists(var PriceListHeader: Record "Price List Header"; var PriceListCode: Code[20]) IsPicked: Boolean;
var
PurchasePriceLists: Page "Purchase Price Lists";
SalesPriceLists: Page "Sales Price Lists";
begin
PriceListCode := '';
case PriceListHeader."Price Type" of
"Price Type"::Sale:
begin
SalesPriceLists.LookupMode(true);
SalesPriceLists.SetRecordFilter(PriceListHeader);
OnBeforeRunSalesPriceList(SalesPriceLists, PriceListHeader);
if SalesPriceLists.RunModal() = Action::LookupOK then begin
SalesPriceLists.GetRecord(PriceListHeader);
PriceListCode := PriceListHeader.Code;
end;
end;
"Price Type"::Purchase:
begin
PurchasePriceLists.LookupMode(true);
PurchasePriceLists.SetRecordFilter(PriceListHeader);
OnBeforeRunPurchasePriceList(PurchasePriceLists, PriceListHeader);
if PurchasePriceLists.RunModal() = Action::LookupOK then begin
PurchasePriceLists.GetRecord(PriceListHeader);
PriceListCode := PriceListHeader.Code;
end;
end;
end;
OnAfterSelectPriceLists(PriceListHeader, PriceListCode);
IsPicked := PriceListCode <> '';
end;
procedure LookupPriceLists(SourceGroup: Enum "Price Source Group"; PriceType: Enum "Price Type"; var PriceListCode: Code[20]) Result: Boolean;
var
PriceListHeader: Record "Price List Header";
begin
if PriceListCode <> '' then begin
PriceListHeader.Get(PriceListCode);
PriceListHeader.SetFilter(Code, '<>%1', PriceListCode);
PriceListCode := '';
end else begin
PriceListHeader."Source Group" := SourceGroup;
PriceListHeader."Price Type" := PriceType;
end;
case SourceGroup of
SourceGroup::Job:
Result := SelectJobPriceLists(PriceListHeader, PriceListCode);
SourceGroup::Customer,
SourceGroup::Vendor:
Result := SelectPriceLists(PriceListHeader, PriceListCode);
end;
OnAfterLookupPriceLists(PriceListHeader, SourceGroup, PriceType, PriceListCode, Result);
end;
procedure EditPriceList(PriceListCode: Code[20])
var
PriceListHeader: Record "Price List Header";
begin
if PriceListCode = '' then
exit;
PriceListHeader.Get(PriceListCode);
SetPriceListsFilters(PriceListHeader, PriceListHeader."Price Type", PriceListHeader."Amount Type");
case PriceListHeader."Price Type" of
PriceListHeader."Price Type"::Sale:
Page.RunModal(Page::"Sales Price List", PriceListHeader);
PriceListHeader."Price Type"::Purchase:
Page.RunModal(Page::"Purchase Price List", PriceListHeader);
end;
OnAfterEditPriceList(PriceListHeader, PriceListCode);
end;
procedure ShowExceptions(CurrPriceCalculationSetup: Record "Price Calculation Setup")
var
DtldPriceCalculationSetup: Page "Dtld. Price Calculation Setup";
begin
DtldPriceCalculationSetup.Set(CurrPriceCalculationSetup);
DtldPriceCalculationSetup.RunModal();
end;
procedure ShowPriceLists(Campaign: Record Campaign; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type")
var
PriceSourceList: Codeunit "Price Source List";
IsHandled: Boolean;
begin
OnBeforeShowPriceLists(Campaign, PriceType, AmountType, IsHandled);
if IsHandled then
exit;
GetPriceSource(Campaign, PriceType, PriceSourceList);
ShowPriceLists(PriceSourceList, AmountType);
end;
procedure ShowPriceLists(Contact: Record Contact; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type")
var
PriceSourceList: Codeunit "Price Source List";
IsHandled: Boolean;
begin
OnBeforeShowPriceLists(Contact, PriceType, AmountType, IsHandled);
if IsHandled then
exit;
GetPriceSource(Contact, PriceType, PriceSourceList);
ShowPriceLists(PriceSourceList, AmountType);
end;
procedure ShowPriceLists(Customer: Record Customer; AmountType: Enum "Price Amount Type")
var
PriceSourceList: Codeunit "Price Source List";
IsHandled: Boolean;
begin
OnBeforeShowPriceLists(Customer, "Price Type"::Sale, AmountType, IsHandled);
if IsHandled then
exit;
GetPriceSource(Customer, PriceSourceList);
ShowPriceLists(PriceSourceList, AmountType);
end;
procedure ShowPriceLists(CustomerDiscountGroup: Record "Customer Discount Group")
var
PriceSourceList: Codeunit "Price Source List";
IsHandled: Boolean;
begin
OnBeforeShowPriceLists(CustomerDiscountGroup, "Price Type"::Sale, "Price Amount Type"::Discount, IsHandled);
if IsHandled then
exit;
GetPriceSource(CustomerDiscountGroup, PriceSourceList);
ShowPriceLists(PriceSourceList, "Price Amount Type"::Discount);
end;
procedure ShowPriceLists(CustomerPriceGroup: Record "Customer Price Group")
var
PriceSourceList: Codeunit "Price Source List";
IsHandled: Boolean;
begin
OnBeforeShowPriceLists(CustomerPriceGroup, "Price Type"::Sale, "Price Amount Type"::Price, IsHandled);
if IsHandled then
exit;
GetPriceSource(CustomerPriceGroup, PriceSourceList);
ShowPriceLists(PriceSourceList, "Price Amount Type"::Price);
end;
procedure ShowPriceLists(Vendor: Record Vendor; AmountType: Enum "Price Amount Type")
var
PriceSourceList: Codeunit "Price Source List";
IsHandled: Boolean;
begin
OnBeforeShowPriceLists(Vendor, "Price Type"::Purchase, AmountType, IsHandled);
if IsHandled then
exit;
GetPriceSource(Vendor, PriceSourceList);
ShowPriceLists(PriceSourceList, AmountType);
end;
procedure ShowPriceLists(Job: Record Job; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type")
var
PriceSourceList: Codeunit "Price Source List";
IsHandled: Boolean;
begin
OnBeforeShowPriceLists(Job, PriceType, AmountType, IsHandled);
if IsHandled then
exit;
GetPriceSource(Job, PriceType, PriceSourceList);
ShowJobPriceLists(PriceSourceList, AmountType);
end;
local procedure ShowJobPriceLists(PriceSourceList: Codeunit "Price Source List"; AmountType: Enum "Price Amount Type")
var
PurchaseJobPriceLists: Page "Purchase Job Price Lists";
SalesJobPriceLists: Page "Sales Job Price Lists";
PriceType: Enum "Price Type";
begin
PriceType := PriceSourceList.GetPriceType();
case PriceType of
PriceType::Sale:
begin
SalesJobPriceLists.SetSource(PriceSourceList, AmountType);
SalesJobPriceLists.Run();
end;
PriceType::Purchase:
begin
PurchaseJobPriceLists.SetSource(PriceSourceList, AmountType);
PurchaseJobPriceLists.Run();
end;
end;
end;
procedure ShowPriceListLines(PriceAsset: Record "Price Asset"; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type")
var
DummyPriceSource: Record "Price Source";
PriceAssetList: Codeunit "Price Asset List";
PriceListLineReview: Page "Price List Line Review";
IsHandled: Boolean;
begin
OnBeforeShowPriceListLines(DummyPriceSource, PriceAsset, PriceType, AmountType, IsHandled);
if IsHandled then
exit;
PriceAssetList.Init();
PriceAssetList.Add(PriceAsset);
OnShowPriceListLinesOnAfterPriceAssetListAdd(PriceAsset, PriceType, PriceAssetList, PriceListLineReview);
PriceListLineReview.Set(PriceAssetList, PriceType, AmountType);
PriceListLineReview.Run();
end;
procedure ShowPriceListLines(PriceSource: Record "Price Source"; PriceAsset: Record "Price Asset"; AmountType: Enum "Price Amount Type")
var
PriceAssetList: Codeunit "Price Asset List";
PriceListLineReview: Page "Price List Line Review";
IsHandled: Boolean;
begin
OnBeforeShowPriceListLines(PriceSource, PriceAsset, PriceSource."Price Type", AmountType, IsHandled);
if IsHandled then
exit;
PriceAssetList.Init();
PriceAssetList.Add(PriceAsset);
PriceListLineReview.Set(PriceSource, PriceAssetList, AmountType);
PriceListLineReview.Run();
end;
procedure ShowPriceListLines(PriceSource: Record "Price Source"; AmountType: Enum "Price Amount Type")
var
DummyPriceAsset: Record "Price Asset";
PriceSourceList: Codeunit "Price Source List";
PriceListLineReview: Page "Price List Line Review";
IsHandled: Boolean;
begin
OnBeforeShowPriceListLines(PriceSource, DummyPriceAsset, PriceSource."Price Type", AmountType, IsHandled);
if IsHandled then
exit;
PriceSourceList.Init();
AddAllSourceType(PriceSourceList, PriceSource."Source Type");
PriceSourceList.AddChildren(PriceSource);
PriceSourceList.Add(PriceSource);
PriceListLineReview.Set(PriceSourceList, AmountType);
PriceListLineReview.Run();
end;
procedure ShowPriceLists(PriceSourceList: Codeunit "Price Source List"; AmountType: Enum "Price Amount Type")
var
PurchasePriceLists: Page "Purchase Price Lists";
SalesPriceLists: Page "Sales Price Lists";
PriceType: Enum "Price Type";
begin
PriceType := PriceSourceList.GetPriceType();
case PriceType of
PriceType::Sale:
begin
SalesPriceLists.SetSource(PriceSourceList, AmountType);
SalesPriceLists.Run();
end;
PriceType::Purchase:
begin
PurchasePriceLists.SetSource(PriceSourceList, AmountType);
PurchasePriceLists.Run();
end;
end;
OnAfterShowPriceLists(PriceSourceList, AmountType, PriceType);
end;
local procedure GetPriceSource(Campaign: Record Campaign; PriceType: Enum "Price Type"; var PriceSourceList: Codeunit "Price Source List")
var
PriceSourceType: Enum "Price Source Type";
begin
OnBeforeGetPriceSource(Campaign, PriceType, PriceSourceList);
PriceSourceList.Add(PriceSourceType::Campaign, Campaign."No.");
PriceSourceList.SetPriceType(PriceType);
OnAfterGetPriceSource(Campaign, PriceSourceList);
end;
local procedure GetPriceSource(Contact: Record Contact; PriceType: Enum "Price Type"; var PriceSourceList: Codeunit "Price Source List")
var
PriceSourceType: Enum "Price Source Type";
begin
OnBeforeGetPriceSource(Contact, PriceType, PriceSourceList);
PriceSourceList.Add(PriceSourceType::Contact, Contact."No.");
PriceSourceList.SetPriceType(PriceType);
OnAfterGetPriceSource(Contact, PriceSourceList);
end;
local procedure GetPriceSource(Customer: Record Customer; var PriceSourceList: Codeunit "Price Source List")
var
PriceSourceType: Enum "Price Source Type";
begin
OnBeforeGetPriceSource(Customer, "Price Type"::Sale, PriceSourceList);
if Customer."Bill-to Customer No." <> '' then
PriceSourceList.Add(PriceSourceType::Customer, Customer."Bill-to Customer No.")
else
PriceSourceList.Add(PriceSourceType::Customer, Customer."No.");
PriceSourceList.Add(PriceSourceType::"All Customers");
if Customer."Customer Price Group" <> '' then
PriceSourceList.Add(PriceSourceType::"Customer Price Group", Customer."Customer Price Group");
if Customer."Customer Disc. Group" <> '' then
PriceSourceList.Add(PriceSourceType::"Customer Disc. Group", Customer."Customer Disc. Group");
OnAfterGetPriceSource(Customer, PriceSourceList);
end;
local procedure GetPriceSource(CustomerPriceGroup: Record "Customer Price Group"; var PriceSourceList: Codeunit "Price Source List")
var
PriceSourceType: Enum "Price Source Type";
begin
OnBeforeGetPriceSource(CustomerPriceGroup, "Price Type"::Sale, PriceSourceList);
PriceSourceList.Add(PriceSourceType::"Customer Price Group", CustomerPriceGroup.Code);
OnAfterGetPriceSource(CustomerPriceGroup, PriceSourceList);
end;
local procedure GetPriceSource(CustomerDiscountGroup: Record "Customer Discount Group"; var PriceSourceList: Codeunit "Price Source List")
var
PriceSourceType: Enum "Price Source Type";
begin
OnBeforeGetPriceSource(CustomerDiscountGroup, "Price Type"::Sale, PriceSourceList);
PriceSourceList.Add(PriceSourceType::"Customer Disc. Group", CustomerDiscountGroup.Code);
OnAfterGetPriceSource(CustomerDiscountGroup, PriceSourceList);
end;
local procedure GetPriceSource(Vendor: Record Vendor; var PriceSourceList: Codeunit "Price Source List")
var
PriceSourceType: Enum "Price Source Type";
begin
OnBeforeGetPriceSource(Vendor, "Price Type"::Purchase, PriceSourceList);
if Vendor."Pay-to Vendor No." <> '' then
PriceSourceList.Add(PriceSourceType::Vendor, Vendor."Pay-to Vendor No.")
else
PriceSourceList.Add(PriceSourceType::Vendor, Vendor."No.");
PriceSourceList.Add(PriceSourceType::"All Vendors");
OnAfterGetPriceSource(Vendor, PriceSourceList);
end;
local procedure GetPriceSource(Job: Record Job; PriceType: Enum "Price Type"; var PriceSourceList: Codeunit "Price Source List")
var
PriceSourceType: Enum "Price Source Type";
begin
OnBeforeGetPriceSource(Job, PriceType, PriceSourceList);
PriceSourceList.Add(PriceSourceType::Job, Job."No.");
PriceSourceList.Add(PriceSourceType::"All Jobs");
PriceSourceList.SetPriceType(PriceType);
OnAfterGetPriceSource(Job, PriceSourceList);
end;
local procedure AddAllSourceType(var PriceSourceList: Codeunit "Price Source List"; SourceType: Enum "Price Source Type")
begin
case SourceType of
"Price Source Type"::Customer:
PriceSourceList.Add("Price Source Type"::"All Customers");
"Price Source Type"::Vendor:
PriceSourceList.Add("Price Source Type"::"All Vendors");
"Price Source Type"::Job,
"Price Source Type"::"Job Task":
PriceSourceList.Add("Price Source Type"::"All Jobs");
end;
end;
procedure SetPriceListsFilters(var PriceListHeader: Record "Price List Header"; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type")
begin
PriceListHeader.FilterGroup(2);
PriceListHeader.SetRange("Price Type", PriceType);
if AmountType <> AmountType::Any then
PriceListHeader.SetFilter("Amount Type", '%1|%2', AmountType, AmountType::Any);
PriceListHeader.FilterGroup(0);
end;
procedure SetPriceListsFilters(var PriceListHeader: Record "Price List Header"; PriceSourceList: Codeunit "Price Source List"; AmountType: Enum "Price Amount Type")
var
PriceListManagement: Codeunit "Price List Management";
begin
PriceListManagement.SetPriceListsFilters(PriceListHeader, PriceSourceList, AmountType);
end;
procedure SetPriceListLineFilters(var PriceListLine: Record "Price List Line"; PriceSourceList: Codeunit "Price Source List"; AmountType: Enum "Price Amount Type")
var
PriceListManagement: Codeunit "Price List Management";
begin
PriceListManagement.SetPriceListLineFilters(PriceListLine, PriceSourceList, AmountType);
end;
procedure SetPriceListLineFilters(PriceAssetList: Codeunit "Price Asset List"; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type"): Boolean;
var
[SecurityFiltering(SecurityFilter::Filtered)]
PriceListLine: Record "Price List Line";
PriceSource: Record "Price Source";
PriceListManagement: Codeunit "Price List Management";
begin
PriceSource."Price Type" := PriceType;
PriceListManagement.FindIfPriceExists();
PriceListManagement.SetPriceListLineFilters(PriceListLine, PriceSource, PriceAssetList, AmountType);
exit(PriceListManagement.IsPriceFound());
end;
procedure SetPriceListLineFilters(var PriceListLine: Record "Price List Line"; PriceAssetList: Codeunit "Price Asset List"; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type")
var
PriceSource: Record "Price Source";
PriceListManagement: Codeunit "Price List Management";
begin
PriceSource."Price Type" := PriceType;
PriceListManagement.SetPriceListLineFilters(PriceListLine, PriceSource, PriceAssetList, AmountType);
end;
procedure SetPriceListLineFilters(var PriceListLine: Record "Price List Line"; PriceSource: Record "Price Source"; PriceAssetList: Codeunit "Price Asset List"; AmountType: Enum "Price Amount Type")
var
PriceListManagement: Codeunit "Price List Management";
begin
PriceListManagement.SetPriceListLineFilters(PriceListLine, PriceSource, PriceAssetList, AmountType);
end;
procedure GetFirstAlternateSetupCode(CurrPriceCalculationSetup: Record "Price Calculation Setup"): Code[100];
var
PriceCalculationSetup: Record "Price Calculation Setup";
begin
if CurrPriceCalculationSetup."Group Id" = '' then
exit('');
PriceCalculationSetup.SetRange("Group Id", CurrPriceCalculationSetup."Group Id");
PriceCalculationSetup.SetRange(Default, false);
if PriceCalculationSetup.FindFirst() then
exit(PriceCalculationSetup.Code)
end;
procedure PickAlternateImplementation(var DtldPriceCalculationSetup: Record "Dtld. Price Calculation Setup");
var
PriceCalculationSetup: Record "Price Calculation Setup";
begin
PriceCalculationSetup.SetRange("Group Id", DtldPriceCalculationSetup."Group Id");
PriceCalculationSetup.SetRange(Default, false);
if Page.RunModal(Page::"Price Calc. Implementations", PriceCalculationSetup) = ACTION::LookupOK then
DtldPriceCalculationSetup.Validate(Implementation, PriceCalculationSetup.Implementation);
end;
procedure TestAlternateImplementation(CurrPriceCalculationSetup: Record "Price Calculation Setup")
var
PriceCalculationSetup: Record "Price Calculation Setup";
begin
PriceCalculationSetup.SetRange("Group Id", CurrPriceCalculationSetup."Group Id");
PriceCalculationSetup.SetRange(Default, false);
if PriceCalculationSetup.IsEmpty() then
Error(MissingAlternateImplementationErr);
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeShowPriceLists(FromRecord: Variant; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type"; var Handled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeShowPriceListLines(PriceSource: Record "Price Source"; var PriceAsset: Record "Price Asset"; PriceType: Enum "Price Type"; AmountType: Enum "Price Amount Type"; var IsHandled: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeGetPriceSource(FromRecord: Variant; PriceType: Enum "Price Type"; var PriceSourceList: Codeunit "Price Source List")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterGetPriceSource(FromRecord: Variant; var PriceSourceList: Codeunit "Price Source List")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnShowPriceListLinesOnAfterPriceAssetListAdd(PriceAsset: Record "Price Asset"; PriceType: Enum "Price Type"; var PriceAssetList: Codeunit "Price Asset List"; var PriceListLineReview: Page "Price List Line Review")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterSelectPriceLists(var PriceListHeader: Record "Price List Header"; var PriceListCode: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterLookupPriceLists(var PriceListHeader: Record "Price List Header"; var SourceGroup: Enum "Price Source Group"; PriceType: Enum "Price Type"; var PriceListCode: Code[20]; var Result: Boolean)
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterEditPriceList(var PriceListHeader: Record "Price List Header"; var PriceListCode: Code[20])
begin
end;
[IntegrationEvent(false, false)]
local procedure OnAfterShowPriceLists(PriceSourceList: Codeunit "Price Source List"; AmountType: Enum "Price Amount Type"; PriceType: Enum "Price Type")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeRunPurchasePriceList(var PurchasePriceLists: Page "Purchase Price Lists"; var PriceListHeader: Record "Price List Header")
begin
end;
[IntegrationEvent(false, false)]
local procedure OnBeforeRunSalesPriceList(var SalesPriceLists: Page "Sales Price Lists"; var PriceListHeader: Record "Price List Header")
begin
end;
}