Version 2025 r2 (release note)

  MyClass = Class(TitObject)
    Procedure TestDeffParams;
    Procedure TestDefParamBool(p1:string; p2:boolean=true);
    Procedure TestDefParamJson(p1:string; p2:TJson=nil);
    Procedure TestDefParamJson2(p1:string; p2:TJson='{a:false}');
    Procedure TestDefParamEnum(p1:string; p2:Integer=WFCAState_Etat2);
    Procedure TestDefParamMulti(p1:string; p2:string='a'; p3:string='b');
    Function TestDefParamOne(p1:string='a'):string;
    Function TestDefParamFunc(p1:string='a'):string;
  end;
 
Procedure MyClass.TestDefParamJson(p1:string; p2:TJson=nil);
var json:TJson;
begin
  json := TJsonStruct.Create('{}');
  //
  // use Assigned insted of p2<>nil
  //
  if assigned(p2) then json.addStruct('p2',p2);
end;
 
Procedure MyClass.TestDeffParams;
var V:string;
begin
  V := TestDefParamFunc('c'); 
  ShowMessage(V); 
 
  TestDefParamOne;
  TestDefParamOne(); 
  TestDefParamOne('x'); 
 
  TestDefParamMulti('a'); 
  TestDefParamMulti('a','1'); 
  TestDefParamMulti('a','1','2'); 
 
  TestDefParamBool('a'); 
  TestDefParamBool('a',false); 
  TestDefParamBool('a',true); 
 
  TestDefParamJson2('b');
  TestDefParamJson2('b','{a:true}'); 
 
  TestDefParamEnum('c');
  TestDefParamEnum('c',WFCAState_Final); 
end;

Type
  MyClass1 = class
    class procedure foo(rg:TRegClass);
  end;
 
  MyClass2 = class
    ....
  end;
 
  MyClass3 = class
    procedure oldbar();
    procedure newbar();
  end;
 
class procedure MyClass1.foo(rg:TRegClass);
begin
  // => MyClass2
  showMessage(rg.aClassName);
end;
 
procedure MyClass3.oldbar();
var rg:TRegClass;
begin
  ModelManager.FindClass('MyClass2');
  myClass1.foo(rg);
end;
 
procedure MyClass3.newbar();
begin
  myClass1.foo(MyClass2);
end;

Procedure TestJson;
 
 function _foo(p:TJson):boolean;
 begin
   Result := false; 
   if 'a' in p then
    begin
      Result := True;
    end; 
 end; 
 
var js:TJson;
begin
  js := TJson.Create('{a:true}'); 
  if _foo(js) then showMessage('ok') else showMessage('nok');
end;

Procedure TestJson;
 
 function _foo(p:TJson):boolean;
 begin
   Result := false; 
   if 'a' in p then
    begin
      Result := p['a'];
    end; 
 end; 
 
var js:TJson;
begin
  js := TJson.Create('{a:true}'); 
  js['b'] := False; 
  js['a'] := not js['b']; 
  if _foo(js) then showMessage('ok') else showMessage('nok');
end;

Procedure TestJson;
 
 function _foo(p:TJson):boolean;
 begin
   Result := false; 
   if 'a' in p then
    begin
      Result := p['a'];
    end; 
 end; 
 
begin
  if _foo('{a:true}') then showMessage('ok') else showMessage('nok');
end;

//Procedure TestJson;
 
 procedure _enumValues(p:TJson);
 var i:Integer; V:Variant;
 begin
   forEach V in p index i do
    begin
      showMessageFmt('%d:%s',[i,V]); 
    end; 
 end; 
 
 procedure _enumKeys(p:TJson);
 var i:Integer; Key,Keys,stag:string; 
 begin
   Keys := ''; stag := '';
   forEach key in p index i do
    begin
      Keys := Keys+stag+inttostr(i)+':'+key;
      stag := ','; 
    end; 
   showMessage(Keys); 
 end; 
 
begin
  _enumKeys('{a:true, b:false}'); 
  _enumValues('[{a:true, b:false},{a:false, b:true}]'); 
end;

class function AllocOID:TOID;

procedure ToJson(SA:variant);

procedure dbgClear();

procedure dbgEnable(value:boolean);

Type
  vue1 = viewOf(ClassA)
   p1:TEnum(enumName) = ...;
   oidRef:TOID = oidrefB;
   ..
   idRefB:TOID = oidrefB notInSelect;
   [ (idRefB=%ArgRefB) and ....]
  end;

Type
  vue1 = viewOf(ClassA)
    ACount:Integer = count(oid)
    oidRef:TOID;
    codeRef:string;
    libelleRef:string;
   ..
   [  ...]
  end;
 
var sel:TSelector;
begin
  sel := vue1.createSelector();
  case iGroupBy of
   'refB':
     begin
       sel.AddColumn('oidrefB','oidRef'); 
       sel.AddColumn('refB.code','codeRef'); 
       sel.AddColumn('refB.Caption','libelleRef'); 
     end;
   'refC':
     begin
       sel.AddColumn('oidrefC','oidRef'); 
       sel.AddColumn('refC.code','codeRef'); 
       sel.AddColumn('refC.Caption','libelleRef'); 
     end;
  end; 
end;

Type
  vue1 = viewOf(ClassA)
   p1:TEnum(enumName) = ...;
  end;

Type
  vue1 = viewOf(ClassA)
   p1:string = expression('...') notInGroupBy;
  end;

Type
  vue1 = viewOf(ClassA)
   p1:string = ...;
   [...]
  end;
 
  vue2 = viewOf(vue1)
   p2:string = ...;
   [inherited and (...)]
  end;

//function GetSelector(iGroupBy:string; iFilter:TJsonArray):TSelector;
Type
  // défini une classe de base avec tous les filtres
  //
  vueEcritureLettrage = viewOf(TEcriture)
    lettrable:boolean = compteGeneral.lettrable notInSelect; 
    idEtablissement:TOID = piece.oidEtablissement notInSelect; 
    idCompteGeneral:TOID = oidCompteGeneral notInSelect; 
    idRoleTiers:TOID = oidroleTiers notInSelect; 
    [(lettrable=true) 
      and ((oidLettrageEcriture='') or (dateLettrage=0)) 
      and (typeEcriture<>0)
      and (piece.lot.origineLot<>0)
      and (eDate>=%ArgDateInf) 
      and (eDate<=%ArgDateSup) 
      and (idEtablissement=%ArgEtablissement) 
      and (idCompteGeneral=%ArgCompteGeneral)
      and (idRoleTiers=%ArgRoleTiers)
    ] 
  end;
 
  // Hérite de tous les filtres
  //
  vueEcritureLettrageGroupBy = viewOf(vueEcritureLettrage)
    dateMin:TDatetime = min(eDate);
    dateMax:TDatetime = max(eDate); 
    ACount:Integer = count(oid); 
    credit:Currency = sum('credit:TCValue'); 
    debit:Currency = sum('debit:TCValue'); 
    solde:Currency = sumDiff(debit,credit); 
    [inherited] 
  end; 
 
begin
  Result := vueLettrageGroupBy.CreateSelector('','',True,[]);
end;

procedure Class1.foo;
Type
  vue1 = viewOf(ClassA)
   p1:string = ...;
  end;
begin
  ...
end;
 
procedure Class2.bar;
Type
  vue2 = viewOf(class1.foo.vue1)
   p2:string = ...;
  end;
begin
  ...
end;

Type
  vue1 = viewOf(ClassA)
   id:string = ...;
  end;
 
  vue2 = viewOf(ClassB)
   id:string = ...;
   bb:boolean = vue1.Exists('(id=self.id)',True,[]) notInSelect;
   [(bb=true) and (....)]
  end;

Type
  VueTauxADate = ViewOf(TTauxADate)
    idTVA : TOid = oidTVA;
    tDate : Date = tDate;
    taux : float = taux; 
  end;
 
  vueMontantTVA = viewOf(TEcriture)
    dateEcriture:TDatetime=eDate notInSelect;
    oidTVA:TOID = ProfilTVA.oidTVA notInSelect; 
    oidPiece:TOID = oidPiece; 
    montantTVAReel:Currency = vueTauxADate.select('taux * self.montant_TCValue /100','(tDate<=self.dateEcriture)and(idTVA=self.oidTVA)','',True,[]); 
    montantTVAReel_CodeDevise:string = montantTVAReel:CodeDevise; 
  end;

//procedure GetData(SRows:TJsonArray);
Type
  myView = viewOf(...)
   ...
  end; 
 
var sel:TSelector; 
begin
  // Selector to retreive the data
  // 
  sel := myView.CreateSelector('','',True,[]);
  sel.ToJson(SRows); 
end;

  TsqlOperation = Class(TsqlObject)
  public
    class procedure CleanOpe(iOpeId:string);
    //
    property action: StringS[128];
    property id: SQLIdentity;
    property oidSourceObject: TOID;
    property oidTargetObject: TOID;
    property opeId: StringS[128];
    property operation: StringS[128];
    property SourceObject: Ref(roGeneric,roNotExternal,roNoForeignKey,roNoRoleIndex) of TitObject;
    property TargetObject: Ref(roGeneric,roNotExternal,roNoForeignKey,roNoRoleIndex) of TitObject;
  end;

 // Créer des écritures a partir des réglements
 //
 procedure  _doCreateEcritureReglements(iOidPiece:string; iOpeId:string);
 var sel:TSelector; 
 begin
   sel := vueEcritureReglement.CreateSelector('(oidBordereau=%1)','',True,[oidBordereauReglement]); 
   sel.AddParameter('ArgBordereau',oidBordereauReglement); 
   sel.Operation := 'EcrReg'; 
   sel.OpeId := iOpeId; 
   // 
   sel.CopyTo('TEcriture',['oidpiece','eDate','sens','sensProrata','regimeTVA','typeEcriture'],[
    iOidPiece,
    BordereauReglement.dateReglement, 
    sens_credit,
    sens_credit, 
    regimeTVA_Encaissements,
    typeEcriture_Brouillard 
   ]); 
 end;
 
 
Type
  vueUpdateReglement = viewOf(TReglement)
   vl:TsqlOperation = join('(opeId=%ArgOpeId) and (operation=%ArgOperation) and (oidSourceObject=self.oid)'); 
   oidEcriture:TOID = oidEcriture; 
   oidTargetEcriture:TOID = vl.oidTargetObject; 
   oidBordereau:TOID = oidBordereauReglement; 
  end; 
 
 // Met à jour l'oidEcriture créée sur les réglements correspondants
 ..
 procedure _doUpdateReglementsEcriture(iOidPiece:string; iOpeId:string);
 var sel:TSelector; 
 begin
   sel := vueUpdateReglement.CreateSelector('(oidBordereau=%1)','',True,[oidBordereauReglement]); 
   sel.AddParameter('ArgOpeId',iOpeId); 
   sel.AddParameter('ArgOperation','EcrReg'); 
   //
   sel.Update(['oidEcriture'],['oidTargetEcriture']); 
 end; 
 
begin
  aOpeId := CreateGuid;
  withP long transaction do
   begin
     aOidPiece := _doCreatePiece();
     _doCreateEcritureReglements(aOidPiece,aOpeId);
     _doUpdateReglementsEcriture(aOidPice,aOpeId); 
     ...
     TsqlOperation.CleanOpe(aOpeId);
   end;
end;

function updateFrom(sel:TSelector; iMatchedProps:Array of string; iUpdatedProps:Array of string; iUpdatedValue:Array of variant):Integer;

Type
  // Update the temp table 
  vueTemp = viewOf(TempLettrage)
    reference1:string = reference1;
    reference2:string = reference2;
    modeLettrage:Integer = modeLettrage; 
  end;
 
  vueRef1 = viewOf(TempLettrage)
    //ACount:Integer = count(id);
    ATotal:Currency = sumSign(montant:TCValue,sens,'1');
    reference1:string = reference1; 
    [(modeLettrage=0) and (reference1<>'')] 
  end; 
 
var selT,selG:TSelector;
begin
  withP long transaction do
    begin
     // for updating the temp table on "match" 
     selT := vueTemp.CreateSelector('','',True,[]);
 
     // Lettrage sur reference 1 
     selG := vueRef1.CreateSelector('(ATotal=0)','',True,[]);
     selG.useCTE := True; 
     selT.UpdateFrom(selG,['reference1'],['modeLettrage'],[1]); 
    end;
end;

Type
  // define an interface
  intf = interface
   ...
  end;
 
  // create a view which support the interface
  // will be used to create the temp table
  //
  vue = viewOf(MyClass,intf)
  end;
 
  // define a sql class based on the interface
  //
  sql = sqlClass(intf)
  end;
 
  // view on the sql class
  //
  vue2 = viewOf(sql)
   ...
  end;
 
var sel:Tselector; aJob,aTempTable:string; keepTables:boolean;
begin
  // Alloc a temp table name
  //
  aJob := CreateGuid;
  aTempTable := ClassManager.DefDatabase.AllocTempTable(aJob);
  KeepTables := false; // for debuging
  try
   // Create a temp table from MyClass view
   //
   sel := vue.CreateSelector(...);
   sel.insertInto(aTempTable,[...],[...]); // we create a tempTable
 
   // Query the temp table throught the vue2 
   //
   sel := vue2.CreateSelector(...);
   sel.SourceTableName := aTempTable; // because we select the tempTable
 
  ...
  finally
  if not KeepTables then ClassManager.DefDatabase.DropTempTables(aJob); 
  end; 
end;

Type
  // Should returns all attributes part of the counter
  //
  vueNumeroPiece = viewOf(TPiece)
   pDate:TDatetime = pDate;
   numero:TCounter = numero; 
  end; 
 
 procedure _doUpdateNumeroPiece(iOidPiece:string);
 var sel:TSelector; vueNP:vueNumeroPiece; upd:TUpdater;
 begin
   upd := TPiece.CreateUpdater('numero'); 
   // 
   sel := vueNumeroPiece.CreateSelector('(oid=%1)','',True,[iOidPiece]);
   forEach vueNP in sel.AsCursor do
    begin
      vueNP.numero.AllocValue;
      upd.AddValue(vueNP.OID,vueNP.numero.value); 
    end; 
   //
   upd.Execute; 
 end; 
 
begin
 
end;