procedure TFacade.LigarTV;
var
  Componentes: TComponentes;
  Sintonizador: TSintonizador;
  Configuracao: TConfiguracao;
begin
  Componentes := TComponentes.Create;
  Sintonizador: TSintonizador.Create;
  Configuracao: TConfiguracao.Create;
  try
    Componentes.LigarComponentes;
    Sintonizador.CarregarListaDeCanais;
    Sintonizador.AcessarUltimoCanal;
    Configuracao.AplicarVolume;
    Configuracao.AplicarModoImagem;
  finally
    FreeAndNil(Componentes);
    FreeAndNil(Sintonizador);
    FreeAndNil(Configuracao);
  end;
end;

var
  Facade: TFacade;
begin
  Facade := TFacade.Create;
  try
    Facade.LigarTV;
  finally
    FreeAndNil(Facade);
  end;
end;

type
  { Subsystem }
  TSubsystemCotacaoDolar = class
  public
    function ConsultarCotacaoDolar: real;
  end;
 
implementation
 
uses
  SysUtils, uWSDL_BCB, SOAPHTTPClient, Windows;
 
{ TSubsystemCotacaoDolar }
 
function TSubsystemCotacaoDolar.ConsultarCotacaoDolar: real;
var
  WebServiceCotacao: FachadaWSSGS;
  HTTPRIO: THTTPRIO;
  FormatSettings : TFormatSettings;
begin
  // cria uma instância da classe THTTPRIO
  HTTPRIO := THTTPRIO.Create(nil);
 
  // obtém uma instância do WSDL
  WebServiceCotacao := GetFachadaWSSGS(True, '', HTTPRIO);
 
  // customiza o separador de decimais para evitar erro de conversão
  FormatSettings.DecimalSeparator := '.';
 
  // invoca o WebService para buscar a cotação do Dólar do dia
  result := StrToFloat(WebServiceCotacao.getUltimoValorVO(1).ultimoValor.sValor, FormatSettings);
end;

type
  { Subsystem }
  TSubsystemCalculoLoja = class
  private
    function AplicarDesconto(const Fidelidade: integer; const Preco: real): real;
    function AplicarMargemVenda(const Preco: real): real;
  public
    function CalcularPrecoFinal(const Fidelidade: integer; const Preco: real): real;
  end;
 
implementation
 
{ TSubsystemCalculoLoja }
 
function TSubsystemCalculoLoja.AplicarDesconto(const Fidelidade: integer;
  const Preco: real): real;
begin
  // Aplica o desconto conforme a fidelidade do cliente
  result := Preco;
  case Fidelidade of
    0: result := Preco - (Preco * 0.02); // Nenhuma - 2% de desconto
    1: result := Preco - (Preco * 0.06); // Bronze - 6% de desconto
    2: result := Preco - (Preco * 0.1);  // Prata - 10% de desconto
    3: result := Preco - (Preco * 0.18); // Ouro - 18% de desconto
  end;
end;
 
function TSubsystemCalculoLoja.AplicarMargemVenda(const Preco: real): real;
begin
  // Aplica a margem de venda de 35%
  result := Preco + (Preco * 0.35);
end;
 
function TSubsystemCalculoLoja.CalcularPrecoFinal(
  const Fidelidade: integer; const Preco: real): real;
begin
  // Operação principal do SubSystem: aplica o desconto e a margem de venda
  result := AplicarDesconto(Fidelidade, Preco);
  result := AplicarMargemVenda(result);
end;

type
  { Subsystem }
  TSubsystemHistorico = class
  public
    procedure RegistrarHistoricoDoCalculo(const Dolar, Preco, ValorVenda: real);
  end;
 
implementation
 
uses
  SysUtils;
 
{ TSubsystemHistorico }
 
procedure TSubsystemHistorico.RegistrarHistoricoDoCalculo(const Dolar, Preco, ValorVenda: real);
var
  Arquivo: TextFile;
  PathArquivo: string;
  Desconto: string;
begin
  // obtém o caminho e nome do arquivo de histórico
  PathArquivo := ExtractFilePath(ParamStr(0)) + 'Historico.txt';
 
  // associa a variável "Arquivo" com o arquivo "Historico.txt"
  AssignFile(Arquivo, PathArquivo);
 
  if FileExists(PathArquivo) then
    // se o arquivo já existe, coloca-o em modo de edição
    Append(Arquivo)
  else
    // caso contrário, cria o arquivo
    Rewrite(Arquivo);
 
  // escreve os dados no arquivo "Historico.txt"
  WriteLn(Arquivo, 'Data..............: ' + FormatDateTime('dd/mm/yyyy', Now));
  WriteLn(Arquivo, 'Cotação do Dólar..: ' + FormatFloat('###,###,##0.00', Dolar));
  WriteLn(Arquivo, 'Conversão em R$...: ' + FormatFloat('###,###,##0.00', Dolar * Preco));
  WriteLn(Arquivo, 'Preço final.......: ' + FormatFloat('###,###,##0.00', ValorVenda));
 
  // fecha o arquivo
  CloseFile(Arquivo);
end;

type
  { Façade }
  TFacade = class
  public
    // operação do Façade
    function CalcularValorDeVenda(const Fidelidade: integer; const Preco: real): real;
  end;
 
implementation
 
uses
  SysUtils, uSubsystemCotacaoDolar, uSubsystemCalculoLoja, uSubsystemHistorico;
 
{ TFacade }
 
function TFacade.CalcularValorDeVenda(const Fidelidade: integer;
  const Preco: real): real;
var
  SubsystemCotacaoDolar: TSubsystemCotacaoDolar;
  SubsystemCalculoLoja: TSubsystemCalculoLoja;
  SubsystemHistorico: TSubsystemHistorico;
  CotacaoDolar: real;
  ValorVenda: real;
begin
  // cria as instâncias dos SubSsystems
  SubsystemCotacaoDolar := TSubsystemCotacaoDolar.Create;
  SubsystemCalculoLoja := TSubsystemCalculoLoja.Create;
  SubsystemHistorico := TSubsystemHistorico.Create;
  try
    // utiliza o primeiro Subsystem para consultar a cotação do Dólar
    CotacaoDolar := SubsystemCotacaoDolar.ConsultarCotacaoDolar;
 
    // converte em Reais
    ValorVenda := Preco * CotacaoDolar;
 
    // utiliza o segundo Subsytem para aplicar desconto e margem de venda
    ValorVenda := SubsystemCalculoLoja.CalcularPrecoFinal(Fidelidade, ValorVenda);
 
    // utiliza o terceiro Subsystem para armazenar o histórico do cálculo
    SubsystemHistorico.RegistrarHistoricoDoCalculo(CotacaoDolar, Preco, ValorVenda);
 
    // retorna o valor calculado 
    result := ValorVenda;
  finally
    // libera as instâncias da memória
    FreeAndNil(SubsystemCotacaoDolar);
    FreeAndNil(SubsystemCalculoLoja);
    FreeAndNil(SubsystemHistorico);
  end;
end;

var
  Fidelidade: smallint;
  Preco: real;
  Facade: TFacade;
  ValorVenda: double;
begin
  Fidelidade := ClientDataSetClientes.FieldByName('Fidelidade').AsInteger;
  Preco := ClientDataSetProdutos.FieldByName('Preco').AsFloat;
 
  // cria uma instância do Façade
  Facade := TFacade.Create;
  try
    // chama o método do Façade que, por sua vez,
    // executa as operações de todos os Subsystems
    ValorVenda := Facade.CalcularValorDeVenda(Fidelidade, Preco);
 
    // exibe uma mensagem com o valor de venda calculado
    ShowMessage(FormatFloat('###,###,##0.00', ValorVenda));
 
    // carrega o log da operação (gerado por um dos Subsystems)
    Memo.Lines.LoadFromFile(ExtractFilePath(ParamStr(0)) + 'Historico.txt');
  finally
    // libera o objeto da memória
    FreeAndNil(Facade);
  end;
end;