Share Button

ORMBr é um framework que vejo ser da maior importância para elevar o CRUD a um novo patamar – vamos dar uma mãozinha para torná-lo mais RAD.

Com o uso de Templates é possível automatizar alguma coisa rotineiras no DELPHI e o deixar mais produtivo. Hoje vamos a um exemplo de como fazer isto.

Primeira informação a saber é que um Template é um XML estruturado que pode ser escrito até no EDITOR de NOTAS, como meu amigo IVAN gosta de fazer ;-).

Quando o Delphi é carregado ele lê os XMLs na pasta de usuário:

  // pasta de templates
  C:\Users\USUARIO\Documents\Embarcadero\Studio\code_templates\Delphi

Vamos criar um arquivo com nome: ORMBr.CreateEntity.xml e copiar para a pasta de templates.

Conteúdo do XML:

   <?xml version="1.0" encoding="utf-8" ?>
<codetemplate	xmlns="http://schemas.borland.com/Delphi/2005/codetemplates"
				version="1.0.0">
	<template name="ormbr.createEntity" invoke="manual">
		<description>
			 Cria modelo para uma tabela
		</description>
		<author>
			 amarildo lacerda
		</author>
        <point name="table">
          <text>table</text>
          </point>
        <point name="description">
          <text>description</text>
          </point>
		<code language="Delphi" delimiter="|"><![CDATA[


interface

uses
  DB,
  Classes,
  SysUtils,
  Generics.Collections,
  /// orm
  ORMBr.types.blob,
  ORMBr.types.lazy,
  ORMBr.types.mapping,
  ORMBr.types.nullable,
  ORMBr.mapping.Classes,
  ORMBr.mapping.register,
  ORMBr.mapping.attributes;

type

  [Entity]
  [Table('|table|', '|description|')]
  T|table| = class
  private

  public

  end;


implementation

initialization

TRegisterClass.RegisterEntity(T|table|);

end.

           ]]>
		</code>
	</template>
</codetemplate>

Se tudo correr bem, agora quando você digitar no editor de código -> “orm + CTRL+J” deverá paracer na lista de opções de templates uma opção “ormbr.createEntity” ….

Share Button

Trocar informações entre RECORDs com estrutura diferentes pode ser um trabalho relativamente cansativa. Uma opção é converter o RECORD de origem em JSON e em seguida carregar o JSON no RECORD de destino.
Executar esta atividade é possível fazendo uso das classes RTTI do delphi. Então a idéia mais básica é criar métodos para gerar JSON e carga do JSON com o RECORD desejado.

Uma proposta utilizando generics para lidar com JSON fontes:


 TJsonRecord<T: Record > = class
  public
     /// gerar JSON
    class function ToJson(O: T; const AIgnoreEmpty: Boolean = true;
      const AProcBefore: TProc < TJsonObject >= nil): string;
     /// carregar um JSON
    class procedure FromJson(O: T; AJson: string);
  end;

Considerando uma estrutura de RECORD (origem e destino):

     TRecordOrigem = record
       nome:string;
       email:string;
     end;


     TRecordDestino = record
       nome:string;
       email:string;
       outros:integer;
     end;

A estrutura de identificação do RECORD por generics tem por finalidade aplicar RTTI para descobrir quais os FIELDS disponíveis no RECORD a ser transformado. Assim quando queremos gerar o JSON, fazemos:

   var sJson:string;
       dados : TRecordOrigem;
   ...
   dados.nome := 'xxxx';
   dados.email := 'yyyy';

   sJson := TJsonRecord<TRecordOrigem>.ToJson(dados);   // retorna o JSON

No RECORD de destino, fazendo a carga do JSON:

   var destino:TRecordDestino;
   ...

   TJsonRecord<TRecordDestino>.FromJson(destino,sJson);

Share Button

“Observer” é inigmático. Você nem esperava e chega aquela notícia que alguma coisa aconteceu. A janela estava lá mostrando uma fila de clientes em atendimento, mas de repente alguém gritou que chegou um cliente com preferência no atendimento e a fila precisa ser reorganizada para acomodar aquele cliente com preferência… Certamente você já viu um cenário deste ou participou de uma fila destas.
Vejamos os atores para o cenário: de uma lado existe alguém pronto para receber a informação de necessidade de reorganizar a fila, ele fica lá só esperando alguém gritar – de outro tem um lá na porta da instituição com sede de saber novidades para sair falando para todo mundo.

Trabalhar com “Observer” é em outras palavras montar uma rede de informação de notícias. Existe um ator que assina o serviço de notícia e outro que distribui as notícias – é isto que um “patterns observer” faz.

Olhando para o MVCBr, o primeiro passo é assinar o serviço de notícias (aquele que fica esperando uma notícia para tomar uma ação):

   uses MVCBr.Observable;

   ... on form show
   // assinar o serviço de notícias
   TMVCBrObservable.subscribe( form1, 'reorganizar.fila',  
                               procedure (json:TJsonValue)
                               var nQtde:integer;
                               begin
                                   nQtde = json.getvalue<integer>('qtde');
                                   abrirVagaNaFila(nQtde);
                               end);

   .... on destroy
   // retirar a assinatura do serviço
   TMVCBrObservable.UnSubscribe(form1);

Do outro lado esta o distribuidor de notícias, aquele que grita que precisa entrar um cliente preferêncial na fila:

   uses MVCBr.Observable;
   ..
    
   // em algum lugar em que a notícia nasce
   TMVCBrObservable.send(  'reorganizar.fila',   TJsonObject.parse(   '{"qtde":1}' ) );


Quando o “observer” recebe a notícia, ele com sede de espalhar a notícia, sai procurando todo mundo que se candidatou para receber aquele serviço… e pá… manda a notícia uma-a-uma para cada assinante.

Aproveitem: git