Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

unit pixelclasses; interface uses System.SysUtils, Rtti, TypInfo; {$TYPEINFO ON} type…

  1. User

    unit pixel_classes;

    interface

    uses System.SysUtils, Rtti, TypInfo;

    {$TYPEINFO ON}

    type TZString = type string;

    type TNullValue = record end;

    TNullable<T{: record}> = record public Value: T; HasValue: Boolean;

    class operator Implicit(const AValue: T): TNullable<T>;
    class operator Implicit(const AValue: TNullable<T>): T;
    class operator Implicit(const AValue: TNullValue): TNullable<T>;
    class operator Explicit(const AValue: T): TNullable<T>;
    
    // add these...
    class operator Equal(const A: TNullable<T>; const B: TNullValue): Boolean;
    class operator NotEqual(const A: TNullable<T>; const B: TNullValue): Boolean;
    

    end;

    var NullValue: TNullValue;

    implementation

    class operator TNullable.Implicit(const AValue: T): TNullable; begin Result.Value := AValue; Result.HasValue := True; end;

    class operator TNullable.Implicit(const AValue: TNullable): T; begin if AValue.HasValue then Result := AValue.Value else Result := Default(T); // or raise an exception end;

    class operator TNullable.Implicit(const AValue: TNullValue): TNullable; begin Result.Value := Default(T); Result.HasValue := False; end;

    class operator TNullable.Explicit(const AValue: T): TNullable; begin Result.Value := AValue; Result.HasValue := True; end;

    class operator TNullable.Equal(const A: TNullable; const B: TNullValue): Boolean; begin Result := not A.HasValue; end;

    class operator TNullable.NotEqual(const A: TNullable; const B: TNullValue): Boolean; begin Result := A.HasValue; end;

    end.


    unit orm_utils;

    interface

    uses System.SysUtils, System.Classes, System.Generics.Collections, System.Generics.Defaults, System.Rtti, System.TypInfo, Data.DB, Uni, pixel_classes, orm_customattributes, Vcl.Controls, Vcl.Forms, Dialogs, Variants;

    type TQryRecInfo = class;

    // Define the event type TPropertyChangedEvent = procedure(Sender: TQryRecInfo; const PropertyName: string) of object;

    EORMUtilsException = class(Exception);

    /// /// Represents the key used in the component-ORM mapping dictionary. /// Combines a reference to an ORM record with a specific field name. /// TORMKey = record ORMRec: TQryRecInfo; FieldName: string; end;

    /// /// Custom comparer for TORMKey to handle equality checks and hashing. /// TORMKeyComparer = class(TEqualityComparer) function Equals(const Left, Right: TORMKey): Boolean; override; function GetHashCode(const Key: TORMKey): Integer; override; end;

    /// /// Manages the binding between UI components and ORM records. /// TORMManager = class private FComponentDict: TDictionary<TORMKey, TComponent>; public constructor Create; destructor Destroy; override;

    /// <summary>
    /// Registers a component with its corresponding ORM record and field name.
    /// </summary>
    procedure RegisterComponent(Component: TComponent; ORMRec: TQryRecInfo; const FieldName: string);
    
    /// <summary>
    /// Unregisters a component from ORM binding.
    /// </summary>
    procedure UnregisterComponent(Component: TComponent);
    
    /// <summary>
    /// Finds the component associated with a specific ORM record and field name.
    /// </summary>
    function FindComponent(ORMRec: TQryRecInfo; const FieldName: string): TComponent;
    
    /// <summary>
    /// Retrieves all registered components.
    /// </summary>
    function GetAllComponents: TArray<TComponent>;
    
    /// <summary>
    /// Updates a component's UI based on the latest ORM record data.
    /// </summary>
    procedure UpdateComponentFromORM(Component: TComponent; ORMRec: TQryRecInfo; const FieldName: string);
    
    /// <summary>
    /// Retrieves the ORM record associated with a given component.
    /// </summary>
    function GetORMRecForComponent(Component: TComponent): TQryRecInfo;
    
    /// <summary>
    /// Retrieves the field name associated with a given component.
    /// </summary>
    function GetFieldNameForComponent(Component: TComponent): string;
    
    /// <summary>
    /// Registers components based on their Hint property.
    /// </summary>
    procedure RegisterComponentsByHint(MyForm: TForm; ORMRec: TQryRecInfo);
    

    end;

    /// /// Helper methods extending TComponent to interface with ORMManager. /// TComponentHelper = class helper for TComponent public /// /// Retrieves the ORM record associated with the component. /// function GetORMRec: TQryRecInfo;

    /// <summary>
    /// Retrieves the field name associated with the component.
    /// </summary>
    function GetORMRecField: string;
    

    end;

    /// /// Base class for query record information /// Use descendants of this class to represent specific database records. /// TQryRecInfo = class private FDirtyFields: TDictionary<string, Boolean>; FPreviousValues: TDictionary<string, TValue>; FOnPropertyChanged: TPropertyChangedEvent; // New event FIsNewRec: Boolean; // New field

    procedure SetInfo(Index: Integer; const Value: TValue);
    // Other SetInfo overloads...
    

    public constructor Create; destructor Destroy; override;

    // Event property
    property OnPropertyChanged: TPropertyChangedEvent read FOnPropertyChanged write FOnPropertyChanged;
    
    // New property
    property IsNewRec: Boolean read FIsNewRec;
    
    // Methods to set nullable fields
    procedure SetInfoNullableString(Index: Integer; const Value: TNullable<string>);
    procedure SetInfoNullableInteger(Index: Integer; const Value: TNullable<Integer>);
    procedure SetInfoNullableInt64(Index: Integer; const Value: TNullable<Int64>);
    procedure SetInfoNullableExtended(Index: Integer; const Value: TNullable<Extended>);
    procedure SetInfoNullableCurrency(Index: Integer; const Value: TNullable<Currency>);
    procedure SetInfoNullableDateTime(Index: Integer; const Value: TNullable<TDateTime>);
    procedure SetInfoNullableBoolean(Index: Integer; const Value: TNullable<Boolean>);
    procedure SetInfoNullableVariant(Index: Integer; const Value: TNullable<Variant>);
    
    // Methods to set non-nullable simple types
    procedure SetInfoCurrency(Index: Integer; const Value: Currency);
    procedure SetInfoString(Index: Integer; const Value: string);
    procedure SetInfoInteger(Index: Integer; const Value: Integer);
    procedure SetInfoInt64(Index: Integer; const Value: Int64);
    procedure SetInfoExtended(Index: Integer; const Value: Extended);
    procedure SetInfoDateTime(Index: Integer; const Value: TDateTime);
    procedure SetInfoBoolean(Index: Integer; const Value: Boolean);
    procedure SetInfoVariant(Index: Integer; const Value: Variant);
    
    // Methods to handle dirty fields
    function IsFieldDirty(const FieldName: string): Boolean;
    procedure ClearDirtyFlags;
    property DirtyFields: TDictionary<string, Boolean> read FDirtyFields;
    
    // Methods to handle previous values
    function GetPreviousValue(const FieldName: string): TValue;
    procedure ClearPreviousValues;
    property PreviousValues: TDictionary<string, TValue> read FPreviousValues;
    
    /// <summary>
    /// Retrieves the formatted text for a given field based on the FmtProp attribute.
    /// </summary>
    function GetFormattedText(const FieldName: string): string;
    
    /// <summary>
    /// Fetches data for this record from the database based on the provided SQL.
    /// </summary>
    procedure Fetch(DBConn: TUniConnection; const QryTxt: string);
    
    /// <summary>
    /// Retrieves the value of a property by name.
    /// </summary>
    /// <param name="PropertyName">The name of the property to retrieve.</param>
    /// <returns>The value of the specified property as TValue.</returns>
    function GetPropertyValue(const PropertyName: string): TValue; // New method
    

    end;

    /// /// Generic class to handle arrays of TQryRecInfo descendants. /// TQryRecArray<T: TQryRecInfo, constructor> = class private FQryRecInfoList: TObjectList; FFilterSQL: string; FDBConn: TUniConnection; function GetCount: Integer; public constructor Create; destructor Destroy; override;

    /// <summary>
    /// Fetches all records based on the provided SQL text and populates the array.
    /// </summary>
    /// <param name="QryTxt">The base SQL query text.</param>
    procedure FetchAllInstance(DBConn: TUniConnection; const QryTxt: string);
    
    /// <summary>
    /// Clears any SQL filters applied.
    /// </summary>
    procedure ClearFilter;
    
    /// <summary>
    /// Accesses a record at the specified index.
    /// </summary>
    /// <param name="Index">The zero-based index of the record.</param>
    /// <returns>The record at the specified index.</returns>
    function Rec(Index: Integer): T;
    
    /// <summary>
    /// Number of records in the array.
    /// </summary>
    property RecCount: Integer read GetCount;
    
    /// <summary>
    /// Database connection used for fetching records.
    /// </summary>
    property DBConn: TUniConnection read FDBConn write FDBConn;
    
    /// <summary>
    /// Additional SQL filter to apply to the query.
    /// </summary>
    property SQLFilter: string read FFilterSQL write FFilterSQL;
    
    /// <summary>
    /// Provides support for for-in loops by returning an enumerator.
    /// </summary>
    function GetEnumerator: TEnumerator<T>;
    
    /// <summary>
    /// Factory method to create and fetch records in a single step.
    /// </summary>
    /// <param name="DBConn">Database connection.</param>
    /// <param name="QryTxt">SQL query text.</param>
    /// <returns>Populated instance of TQryRecArray<T>.</returns>
    class function FetchAll(DBConn: TUniConnection; const QryTxt: string): TQryRecArray<T>; static;
    

    end;

    // Declare ORMManager as a global variable in the interface for accessibility var ORMManager: TORMManager;

    implementation

    uses pixel_utils, System.Math, System.Types, Windows, Vcl.StdCtrls, Vcl.WinXCtrls, Vcl.WinXPickers, StrUtils, DateUtils, System.Hash;

    // ============================= // TORMKeyComparer Implementation // =============================

    function TORMKeyComparer.Equals(const Left, Right: TORMKey): Boolean; begin Result := (Left.ORMRec = Right.ORMRec) and SameText(Left.FieldName, Right.FieldName); end;

    function TORMKeyComparer.GetHashCode(const Key: TORMKey): Integer; begin Result := Integer(NativeUInt(Key.ORMRec)) xor THashBobJenkins.GetHashValue(LowerCase(Key.FieldName)); end;

    // ============================= // TORMManager Implementation // =============================

    constructor TORMManager.Create; begin inherited Create; FComponentDict := TDictionary<TORMKey, TComponent>.Create(TORMKeyComparer.Create); end;

    destructor TORMManager.Destroy; begin FComponentDict.Free; inherited; end;

    procedure TORMManager.RegisterComponent(Component: TComponent; ORMRec: TQryRecInfo; const FieldName: string); var Key: TORMKey; begin Key.ORMRec := ORMRec; Key.FieldName := FieldName;

    if not FComponentDict.ContainsKey(Key) then begin FComponentDict.Add(Key, Component); end; end;

    procedure TORMManager.UnregisterComponent(Component: TComponent); var Key: TORMKey; CopyKeys: TArray; i: Integer; begin // To safely remove components, first copy the keys CopyKeys := FComponentDict.Keys.ToArray; for i := 0 to Length(CopyKeys) - 1 do begin Key := CopyKeys[i]; if FComponentDict[Key] = Component then FComponentDict.Remove(Key); end; end;

    function TORMManager.FindComponent(ORMRec: TQryRecInfo; const FieldName: string): TComponent; var Key: TORMKey; begin Key.ORMRec := ORMRec; Key.FieldName := FieldName; if FComponentDict.TryGetValue(Key, Result) then Exit else Result := nil; end;

    function TORMManager.GetAllComponents: TArray; var Comp: TComponent; CompList: TList; begin CompList := TList.Create; try for Comp in FComponentDict.Values do CompList.Add(Comp); Result := CompList.ToArray; finally CompList.Free; end; end;

    // Helper function to format information based on type function FormataInfo(info: Variant; tipo: TFormatType): string; begin if VarIsNull(info) or VarIsEmpty(info) then Exit('');

    case tipo of tiString: Result := VarToStr(info); tiInteger: Result := IntToStr(Integer(info)); tiMoney: Result := FormatFloat(FMT_MONEY, Currency(info)); tiFloat: Result := FloatToStr(info); tiDate: if VarIsType(info, [varDate, varDouble]) then begin if VarToDateTime(info) < EncodeDate(1900, 1, 1) then Result := '' else Result := FormatDateTime('dd/mm/yyyy', VarToDateTime(info)); end else raise EORMUtilsException.CreateFmt('FormataInfo: Cannot treat information [%s] as tiDate.', [VarToStr(info)]); tiDateTime: if VarIsType(info, [varDate, varDouble]) then begin if VarToDateTime(info) = 0 then Result := '' else Result := FormatDateTime('dd/mm/yyyy hh:mm:ss', VarToDateTime(info)); end else raise EORMUtilsException.CreateFmt('FormataInfo: Cannot treat information [%s] as tiDateTime.', [VarToStr(info)]); tiBoolean: Result := IfThen(Boolean(info), 'S', 'N'); tiByteArray: Result := ByteArrayToHex(info); tiNone: Result := ''; else raise EORMUtilsException.CreateFmt('FormataInfo: Format type [%s] not recognized.', [GetEnumName(TypeInfo(TFormatType), Integer(tipo))]); end; end;

    procedure SetValueToComponent(aComponent: TComponent; TipoProp: TFormatType; Value: Variant); begin if not Assigned(aComponent) then Exit;

    if TipoProp in [tiString, tiInteger, tiMoney, tiFloat, tiByteArray] then begin if IsPublishedProp(aComponent, 'Text') then SetPropValue(aComponent, 'Text', FormataInfo(Value, TipoProp)) else if IsPublishedProp(aComponent, 'Caption') then SetPropValue(aComponent, 'Caption', FormataInfo(Value, TipoProp)) else if IsPublishedProp(aComponent, 'Lines') then begin var Ctx: TRttiContext; Ctx:= TRttiContext.Create; var LineObjProp:= Ctx.GetType(aComponent.ClassType).GetProperty('Lines'); var Strings_Obj:= TStrings(LineObjProp.GetValue(aComponent).AsObject); Strings_Obj.Text:= FormataInfo(Value, TipoProp); // LineObjProp.SetValue(aComponent, Strings_Obj); end;

    end else if TipoProp in [tiDate, tiDateTime] then begin if IsPublishedProp(aComponent, 'Date') then begin if (DateOf(Value) < EncodeDate(1900, 1, 1)) and (not IsPublishedProp(aComponent, 'Text')) then begin SetPropValue(aComponent, 'Date', DateOf(Now)); var Ctx: TRttiContext; Ctx:= TRttiContext.Create; Ctx.GetType(aComponent.ClassType).GetMethod('Clear').Invoke(aComponent, []); // Limpa o campo Date end else SetPropValue(aComponent, 'Date', Value); end else if IsPublishedProp(aComponent, 'Text') then SetPropValue(aComponent, 'Text', FormataInfo(Value, TipoProp)) else if IsPublishedProp(aComponent, 'Caption') then SetPropValue(aComponent, 'Caption', FormataInfo(Value, TipoProp)); end else if TipoProp = tiBoolean then begin if IsPublishedProp(aComponent, 'Checked') then SetPropValue(aComponent, 'Checked', Boolean(Value)) else if IsPublishedProp(aComponent, 'Text') then SetPropValue(aComponent, 'Text', FormataInfo(Value, TipoProp)) else if IsPublishedProp(aComponent, 'Caption') then SetPropValue(aComponent, 'Caption', FormataInfo(Value, TipoProp)); end else raise Exception.Create('SetValueToComponent: o Componente [' + aComponent.Name + ': ' + aComponent.ClassName + '] não está tratado'); end;

    procedure TORMManager.UpdateComponentFromORM(Component: TComponent; ORMRec: TQryRecInfo; const FieldName: string); var Ctx: TRttiContext; RttiType: TRttiType; Prop: TRttiProperty; Attr: TCustomAttribute; FmtAttr: FmtPropAttribute; begin var ORMValue:= ORMRec.GetPropertyValue(FieldName).AsVariant;

    Ctx := TRttiContext.Create;

    RttiType := Ctx.GetType(ORMRec.ClassType);
    Prop := RttiType.GetProperty(FieldName);
    if not Assigned(Prop) then
      raise EORMUtilsException.CreateFmt('Property "%s" not found.', [FieldName]);
    

    var FmtType := tiNone;

    // Check for FmtProp attribute on the property
    for Attr in Prop.GetAttributes do
    begin
      if Attr is FmtPropAttribute then
      begin
        FmtAttr := FmtPropAttribute(Attr);
        FmtType := FmtAttr.FormatType;
        Break;
      end;
    end;
    
    // If not found on property, check on the corresponding field
    if FmtType = tiNone then
    begin
      var Field := RttiType.GetField('_' + FieldName);
      if Assigned(Field) then
      begin
        for Attr in Field.GetAttributes do
        begin
          if Attr is FmtPropAttribute then
          begin
            FmtAttr := FmtPropAttribute(Attr);
            FmtType := FmtAttr.FormatType;
            Break;
          end;
        end;
      end;
    end;
    

    // Determine default FmtType based on property type if not set by attribute if FmtType = tiNone then begin var UnderlyingType := Prop.PropertyType;

      // Handle TNullable<T>
      if UnderlyingType.TypeKind = tkRecord then
      begin
        var ValueField := UnderlyingType.GetField('Value');
        if Assigned(ValueField) then
          UnderlyingType := ValueField.FieldType;
      end;
    
      case UnderlyingType.TypeKind of
        tkInteger, tkInt64:
          FmtType := tiInteger;
        tkFloat:
          if UnderlyingType.Handle = TypeInfo(TDateTime) then
            FmtType := tiDateTime
          else
            FmtType := tiFloat;
        tkString, tkLString, tkWString, tkUString:
          FmtType := tiString;
        tkEnumeration:
          if UnderlyingType.Handle = TypeInfo(Boolean) then
            FmtType := tiBoolean
          else
            FmtType := tiString;
        tkVariant:
          FmtType := tiString;
      else
        FmtType := tiNone;
      end;
    end;
    

    // showmessage(GetEnumName(TypeInfo(TFormatType), Integer(FmtType)));

    if not VarIsNull(ORMValue) then begin if IsPublishedProp(Component, 'Date') then begin if TDateTime(ORMValue) >= EncodeDate(1900, 1, 1) then SetValueToComponent(Component, FmtType, ORMValue) else SetValueToComponent(Component, FmtType, EncodeDate(1899, 01, 01)); end else SetValueToComponent(Component, FmtType, ORMValue); end else begin SetValueToComponent(Component, FmtType, ORMValue.NullToDefault); if IsPublishedProp(Component, 'Date') then begin if IsPublishedProp(Component, 'Text') then begin var Ctx2: TRttiContext; Ctx2:= TRttiContext.Create; Ctx2.GetType(Component.ClassType).GetProperty('Text').SetValue(Pointer(Component), TValue.FromVariant('')); // Limpa o campo Text end else begin var Ctx2: TRttiContext; Ctx2:= TRttiContext.Create; Ctx2.GetType(Component.ClassType).GetMethod('Clear').Invoke(Component, []); // Limpa o campo Date end; end; end; end;

    function TORMManager.GetORMRecForComponent(Component: TComponent): TQryRecInfo; var Key: TORMKey; begin Result := nil; for Key in FComponentDict.Keys do if FComponentDict[Key] = Component then begin Result := Key.ORMRec; Exit; end; end;

    function TORMManager.GetFieldNameForComponent(Component: TComponent): string; var Key: TORMKey; begin Result := ''; for Key in FComponentDict.Keys do if FComponentDict[Key] = Component then begin Result := Key.FieldName; Exit; end; end;

    procedure TORMManager.RegisterComponentsByHint(MyForm: TForm; ORMRec: TQryRecInfo); var Context: TRttiContext; RttiType: TRttiType; RttiProperty: TRttiProperty; Component: TComponent; HintValue: TValue; begin Context := TRttiContext.Create; try for Component in MyForm do begin RttiType := Context.GetType(Component.ClassType); RttiProperty := RttiType.GetProperty('Hint');

      if Assigned(RttiProperty) then
      begin
        HintValue := RttiProperty.GetValue(Component);
        if HintValue.IsEmpty then
          Continue;
    
        RttiType := Context.GetType(ORMRec.ClassType);
        for RttiProperty in RttiType.GetProperties do
        begin
          if (RttiProperty.Visibility = mvPublished) then
          begin
            if SameText(HintValue.AsString, RttiProperty.Name) then
            begin
              RegisterComponent(Component, ORMRec, RttiProperty.Name);
              Break;
            end;
          end;
        end;
      end;
    end;
    

    finally Context.Free; end; end;

    // ============================= // TComponentHelper Implementation // =============================

    function TComponentHelper.GetORMRec: TQryRecInfo; begin Result := ORMManager.GetORMRecForComponent(Self); end;

    function TComponentHelper.GetORMRecField: string; begin Result := ORMManager.GetFieldNameForComponent(Self); end;

    // ============================= // TQryRecInfo Implementation // =============================

    constructor TQryRecInfo.Create; begin inherited Create; FDirtyFields := TDictionary<string, Boolean>.Create; FPreviousValues := TDictionary<string, TValue>.Create; FIsNewRec := False; // Initialize as not new end;

    destructor TQryRecInfo.Destroy; begin FDirtyFields.Free; FPreviousValues.Free; inherited; end;

    procedure TQryRecInfo.ClearDirtyFlags; begin FDirtyFields.Clear; FIsNewRec := False; // Reset IsNewRec when clearing dirty flags end;

    procedure TQryRecInfo.ClearPreviousValues; begin FPreviousValues.Clear; end;

    function TQryRecInfo.IsFieldDirty(const FieldName: string): Boolean; begin Result := FDirtyFields.ContainsKey(FieldName) and FDirtyFields[FieldName]; end;

    function TQryRecInfo.GetPreviousValue(const FieldName: string): TValue; begin if not FPreviousValues.TryGetValue(FieldName, Result) then raise EORMUtilsException.CreateFmt('No previous value found for field "%s".', [FieldName]); end;

    function TQryRecInfo.GetFormattedText(const FieldName: string): string; var Ctx: TRttiContext; RttiType: TRttiType; Prop: TRttiProperty; Field: TRttiField; Value: TValue; FmtType: TFormatType; UnderlyingType: TRttiType; HasValueField: TRttiField; ValueField: TRttiField; HasValue: Boolean; ActualValue: TValue; Attr: TCustomAttribute; FmtAttr: FmtPropAttribute; begin Result := ''; Ctx := TRttiContext.Create; try RttiType := Ctx.GetType(Self.ClassType);

    // Find the property by name
    Prop := RttiType.GetProperty(FieldName);
    if not Assigned(Prop) then
      raise EORMUtilsException.CreateFmt('Property "%s" not found.', [FieldName]);
    
    // Get the value of the property
    Value := Prop.GetValue(Self);
    FmtType := tiNone;
    
    // Check for FmtProp attribute on the property
    for Attr in Prop.GetAttributes do
    begin
      if Attr is FmtPropAttribute then
      begin
        FmtAttr := FmtPropAttribute(Attr);
        FmtType := FmtAttr.FormatType;
        Break;
      end;
    end;
    
    // If not found on property, check on the corresponding field
    if FmtType = tiNone then
    begin
      Field := RttiType.GetField('_' + FieldName);
      if Assigned(Field) then
      begin
        for Attr in Field.GetAttributes do
        begin
          if Attr is FmtPropAttribute then
          begin
            FmtAttr := FmtPropAttribute(Attr);
            FmtType := FmtAttr.FormatType;
            Break;
          end;
        end;
      end;
    end;
    
    // Determine default FmtType based on property type if not set by attribute
    if FmtType = tiNone then
    begin
      UnderlyingType := Prop.PropertyType;
    
      // Handle TNullable<T>
      if UnderlyingType.TypeKind = tkRecord then
      begin
        ValueField := UnderlyingType.GetField('Value');
        if Assigned(ValueField) then
          UnderlyingType := ValueField.FieldType;
      end;
    
      case UnderlyingType.TypeKind of
        tkInteger, tkInt64:
          FmtType := tiInteger;
        tkFloat:
          if UnderlyingType.Handle = TypeInfo(TDateTime) then
            FmtType := tiDateTime
          else
            FmtType := tiFloat;
        tkString, tkLString, tkWString, tkUString:
          FmtType := tiString;
        tkEnumeration:
          if UnderlyingType.Handle = TypeInfo(Boolean) then
            FmtType := tiBoolean
          else
            FmtType := tiString;
        tkVariant:
          FmtType := tiString;
      else
        FmtType := tiNone;
      end;
    end;
    
    // Extract actual value from TNullable<T> if necessary
    if Value.Kind = tkRecord then
    begin
      // Assuming TNullable<T> has 'HasValue' and 'Value' fields
      UnderlyingType := Prop.PropertyType;
      HasValueField := UnderlyingType.GetField('HasValue');
      ValueField := UnderlyingType.GetField('Value');
    
      if Assigned(HasValueField) and Assigned(ValueField) then
      begin
        HasValue := HasValueField.GetValue(Value.GetReferenceToRawData).AsBoolean;
        if HasValue then
        begin
          ActualValue := ValueField.GetValue(Value.GetReferenceToRawData);
          // Format the actual value
          Result := FormataInfo(ActualValue.AsVariant, FmtType);
        end
        else
          Result := '';
      end
      else
      begin
        // Not TNullable<T>, handle value directly
        if not Value.IsEmpty then
          Result := FormataInfo(Value.AsVariant, FmtType)
        else
          Result := '';
      end;
    end
    else
    begin
      // Not a record, handle value directly
      if not Value.IsEmpty then
        Result := FormataInfo(Value.AsVariant, FmtType)
      else
        Result := '';
    end;
    

    finally // No need to free TRttiContext as it's a record end; end;

    procedure TQryRecInfo.Fetch(DBConn: TUniConnection; const QryTxt: string); var qr: TUniQuery; Ctx: TRttiContext; ObjType: TRttiType; Prop: TRttiProperty; Field: TField; ORMFieldName: string; begin if not Assigned(DBConn) or Trim(QryTxt).IsEmpty then Exit;

    qr := TUniQuery.Create(nil); try qr.Connection := DBConn; qr.SpecificOptions.Values['FetchAll'] := 'True'; qr.SpecificOptions.Values['CreateConnection'] := 'False'; qr.SQL.Text := QryTxt; qr.Open;

    if qr.RecordCount > 0 then
    begin
      Ctx := TRttiContext.Create;
      try
        ObjType := Ctx.GetType(Self.ClassType);
    
        for Prop in ObjType.GetProperties do
        begin
          if not Prop.IsWritable then
            Continue;
    
          // Attempt to find the corresponding field in the query
          Field := qr.FindField(Prop.Name);
          if not Assigned(Field) then
            Continue; // Field not found, skip
    
          ORMFieldName := '_' + Prop.Name;
          // Handle TNullable<T> types
          if Prop.PropertyType.TypeKind = tkRecord then
          begin
            // Expecting TNullable<T>
            // Attempt to find the backing field for the nullable property
            if ObjType.GetField(ORMFieldName) = nil then
              Continue; // Backing field not found, skip
    
            if Prop.PropertyType.Name.StartsWith('TNullable<') then
            begin
              // Use RTTI to determine the generic type parameter
              if Field.IsNull then
                ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<string>>(NullValue))
              else
              begin
                if Prop.PropertyType.Name = 'TNullable<System.string>' then
                  ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<string>>(Field.AsString))
                else if Prop.PropertyType.Name = 'TNullable<System.Integer>' then
                  ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<Integer>>(Field.AsInteger))
                else if Prop.PropertyType.Name = 'TNullable<System.Int64>' then
                  ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<Int64>>(Field.AsLargeInt))
                else if Prop.PropertyType.Name = 'TNullable<System.Extended>' then
                  ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<Extended>>(Field.AsFloat))
                else if Prop.PropertyType.Name = 'TNullable<System.Currency>' then
                  ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<Currency>>(Field.AsCurrency))
                else if Prop.PropertyType.Name = 'TNullable<System.TDateTime>' then
                  ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<TDateTime>>(Field.AsDateTime))
                else if Prop.PropertyType.Name = 'TNullable<System.Boolean>' then
                  ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<Boolean>>(Field.AsBoolean))
                else if Prop.PropertyType.Name = 'TNullable<System.Variant>' then
                  ObjType.GetField(ORMFieldName).SetValue(Self, TValue.From<TNullable<Variant>>(Field.Value))
                else
                  raise EORMUtilsException.CreateFmt('Unsupported TNullable type: %s', [Prop.PropertyType.Name]);
              end;
            end
            else
              raise EORMUtilsException.CreateFmt('Unsupported record type: %s', [Prop.PropertyType.Name]);
          end
          else
          begin
            // Handle non-nullable types
            case Prop.PropertyType.TypeKind of
              tkString, tkLString, tkWString, tkUString:
                ObjType.GetField(ORMFieldName).SetValue(Self, Field.AsString);
              tkInteger:
                ObjType.GetField(ORMFieldName).SetValue(Self, Field.AsInteger);
              tkInt64:
                ObjType.GetField(ORMFieldName).SetValue(Self, Field.AsLargeInt);
              tkFloat:
                if Prop.PropertyType.Handle = TypeInfo(Currency) then
                  ObjType.GetField(ORMFieldName).SetValue(Self, Field.AsCurrency)
                else
                  ObjType.GetField(ORMFieldName).SetValue(Self, Field.AsFloat);
              tkVariant:
                ObjType.GetField(ORMFieldName).SetValue(Self, TValue.FromVariant(Field.AsVariant));
              tkEnumeration:
                if Prop.PropertyType.Handle = TypeInfo(Boolean) then
                  ObjType.GetField(ORMFieldName).SetValue(Self, Field.AsBoolean)
                else
                  raise EORMUtilsException.CreateFmt('Unsupported enumeration type: %s', [Prop.PropertyType.Name]);
            else
              // Add additional handling for other types if necessary
            end;
          end;
        end;
    
        // After fetching, reset dirty flags and IsNewRec
        ClearDirtyFlags;
      finally
        // No need to free TRttiContext as it's a record
      end;
    end;
    

    finally qr.Free; end; end;

    procedure TQryRecInfo.SetInfo(Index: Integer; const Value: TValue); var PropName: string; PropKind: TTypeKind; Ctx: TRttiContext; Prop: TRttiProperty; Field: TRttiField; OldValue: TValue; begin // Retrieve property name and kind based on index // Assuming that the index corresponds to the property order Ctx := TRttiContext.Create; try Prop := Ctx.GetType(Self.ClassType).GetProperties()[Index]; if not Assigned(Prop) then raise EORMUtilsException.CreateFmt('Error: The index "%d" does not correspond to any property in class "%s".', [Index, ClassName]);

    PropName := Prop.Name;
    PropKind := Prop.PropertyType.TypeKind;
    
    Field := Ctx.GetType(Self.ClassType).GetField('_' + PropName);
    if not Assigned(Field) then
      raise EORMUtilsException.CreateFmt('Error: Field "_%s" not found in class "%s".', [PropName, ClassName]);
    
    // If the field is not yet dirty, store the previous value
    if not FDirtyFields.ContainsKey(PropName) then
    begin
      OldValue := Field.GetValue(Self);
      FPreviousValues.AddOrSetValue(PropName, OldValue);
      // Since a field is being modified, mark IsNewRec as true
      FIsNewRec := True;
    end;
    
    // Set the new value
    Field.SetValue(Self, Value);
    
    // Mark the property as dirty
    FDirtyFields.AddOrSetValue(PropName, True);
    
    // Trigger the OnPropertyChanged event
    if Assigned(FOnPropertyChanged) then
      FOnPropertyChanged(Self, PropName);
    
    // Update corresponding component if any
    var UpdatedComp := ORMManager.FindComponent(Self, PropName);
    if Assigned(UpdatedComp) then
      ORMManager.UpdateComponentFromORM(UpdatedComp, ORMManager.GetORMRecForComponent(UpdatedComp), ORMManager.GetFieldNameForComponent(UpdatedComp));
    

    finally // No need to free TRttiContext as it's a record end; end;

    procedure TQryRecInfo.SetInfoCurrency(Index: Integer; const Value: Currency); begin SetInfo(Index, TValue.From(Value)); end;

    procedure TQryRecInfo.SetInfoString(Index: Integer; const Value: string); begin SetInfo(Index, TValue.From(Value)); end;

    procedure TQryRecInfo.SetInfoInteger(Index: Integer; const Value: Integer); begin SetInfo(Index, TValue.From(Value)); end;

    procedure TQryRecInfo.SetInfoInt64(Index: Integer; const Value: Int64); begin SetInfo(Index, TValue.From(Value)); end;

    procedure TQryRecInfo.SetInfoExtended(Index: Integer; const Value: Extended); begin SetInfo(Index, TValue.From(Value)); end;

    procedure TQryRecInfo.SetInfoDateTime(Index: Integer; const Value: TDateTime); begin SetInfo(Index, TValue.From(Value)); end;

    procedure TQryRecInfo.SetInfoBoolean(Index: Integer; const Value: Boolean); begin SetInfo(Index, TValue.From(Value)); end;

    procedure TQryRecInfo.SetInfoVariant(Index: Integer; const Value: Variant); begin SetInfo(Index, TValue.From(Value)); end;

    procedure TQryRecInfo.SetInfoNullableBoolean(Index: Integer; const Value: TNullable); begin SetInfo(Index, TValue.From<TNullable>(Value)); end;

    procedure TQryRecInfo.SetInfoNullableCurrency(Index: Integer; const Value: TNullable); begin SetInfo(Index, TValue.From<TNullable>(Value)); end;

    procedure TQryRecInfo.SetInfoNullableDateTime(Index: Integer; const Value: TNullable); begin SetInfo(Index, TValue.From<TNullable>(Value)); end;

    procedure TQryRecInfo.SetInfoNullableExtended(Index: Integer; const Value: TNullable); begin SetInfo(Index, TValue.From<TNullable>(Value)); end;

    procedure TQryRecInfo.SetInfoNullableInteger(Index: Integer; const Value: TNullable); begin SetInfo(Index, TValue.From<TNullable>(Value)); end;

    procedure TQryRecInfo.SetInfoNullableInt64(Index: Integer; const Value: TNullable); begin SetInfo(Index, TValue.From<TNullable>(Value)); end;

    procedure TQryRecInfo.SetInfoNullableString(Index: Integer; const Value: TNullable); begin SetInfo(Index, TValue.From<TNullable>(Value)); end;

    procedure TQryRecInfo.SetInfoNullableVariant(Index: Integer; const Value: TNullable); begin SetInfo(Index, TValue.From<TNullable>(Value)); end;

    function TQryRecInfo.GetPropertyValue(const PropertyName: string): TValue; var ctx: TRttiContext; rttiType: TRttiType; prop: TRttiProperty; UnderlyingType: TRttiType; Value: TValue; ValueField: TRttiField; HasValueField: TRttiField; HasValue: Boolean; ActualValue: TValue; begin // Initialize the result Result := TValue.Empty;

    ctx := TRttiContext.Create; try rttiType := ctx.GetType(Self.ClassType); prop := rttiType.GetProperty(PropertyName); if not Assigned(prop) then raise EORMUtilsException.CreateFmt('Property "%s" not found in class "%s".', [PropertyName, Self.ClassName]);

    // Get the value of the property
    Value := prop.GetValue(Self);
    
    // Check if the property is a TNullable<T>
    if prop.PropertyType.TypeKind = tkRecord then
    begin
      // Assuming TNullable<T> has 'HasValue' and 'Value' fields
      ValueField := prop.PropertyType.GetField('Value');
      HasValueField := prop.PropertyType.GetField('HasValue');
    
      if Assigned(ValueField) and Assigned(HasValueField) then
      begin
        HasValue := HasValueField.GetValue(Value.GetReferenceToRawData).AsBoolean;
        if HasValue then
        begin
          ActualValue := ValueField.GetValue(Value.GetReferenceToRawData);
          Result := ActualValue;
        end
        else
        begin
          // Represent null value appropriately, e.g., using TValue.Empty or a custom indicator
          Result := TValue.Empty; // Or you can use a specific value or structure to indicate null
        end;
      end
      else
      begin
        // Not a TNullable<T>, return the value directly
        Result := Value;
      end;
    end
    else
    begin
      // Non-record types, return the value directly
      Result := Value;
    end;
    

    finally // TRttiContext is a record; no need to free end; end;

    // ============================= // TQryRecArray Implementation // =============================

    constructor TQryRecArray.Create; begin inherited Create; FQryRecInfoList := TObjectList.Create(True); // Owns objects end;

    destructor TQryRecArray.Destroy; begin FQryRecInfoList.Free; inherited; end;

    procedure TQryRecArray.ClearFilter; begin FFilterSQL := ''; end;

    function TQryRecArray.GetCount: Integer; begin Result := FQryRecInfoList.Count; end;

    function TQryRecArray.Rec(Index: Integer): T; begin if (Index < 0) or (Index >= FQryRecInfoList.Count) then raise EORMUtilsException.CreateFmt('Index %d out of bounds.', [Index]);

    Result := FQryRecInfoList[Index]; end;

    procedure TQryRecArray.FetchAllInstance(DBConn: TUniConnection; const QryTxt: string); var qr: TUniQuery; RecInstance: T; Ctx: TRttiContext; ObjType: TRttiType; Prop: TRttiProperty; Field: TField; ORMFieldName: string; begin if not Assigned(DBConn) then raise EORMUtilsException.Create('Database connection (DBConn) is not assigned.');

    if Trim(QryTxt).IsEmpty then raise EORMUtilsException.Create('Query text (QryTxt) cannot be empty.');

    qr := TUniQuery.Create(nil); try qr.Connection := DBConn; qr.SpecificOptions.Values['FetchAll'] := 'True'; qr.SpecificOptions.Values['CreateConnection'] := 'False'; qr.SQL.Text := QryTxt; qr.Open;

    if qr.IsEmpty then
      Exit; // No records to fetch
    
    Ctx := TRttiContext.Create;
    ObjType := Ctx.GetType(T);
    
    try
      while not qr.Eof do
      begin
        RecInstance := T.Create;
        try
          // Iterate over each property of T and assign values from the query
          for Prop in ObjType.GetProperties do
          begin
            if not Prop.IsWritable then
              Continue;
    
            // Attempt to find the corresponding field in the query
            Field := qr.FindField(Prop.Name);
            if not Assigned(Field) then
              Continue; // Field not found, skip
    
            ORMFieldName := '_' + Prop.Name;
    
            // Handle TNullable<T> types
            if Prop.PropertyType.TypeKind = tkRecord then
            begin
              // Expecting TNullable<T>
              // Attempt to find the backing field for the nullable property
              if ObjType.GetField(ORMFieldName) = nil then
                Continue; // Backing field not found, skip
    
              if Prop.PropertyType.Name.StartsWith('TNullable<') then
              begin
                // Use RTTI to determine the generic type parameter
                if Field.IsNull then
                  ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<string>>(NullValue))
                else
                begin
                  if Prop.PropertyType.Name = 'TNullable<System.string>' then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<string>>(Field.AsString))
                  else if Prop.PropertyType.Name = 'TNullable<System.Integer>' then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<Integer>>(Field.AsInteger))
                  else if Prop.PropertyType.Name = 'TNullable<System.Int64>' then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<Int64>>(Field.AsLargeInt))
                  else if Prop.PropertyType.Name = 'TNullable<System.Extended>' then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<Extended>>(Field.AsFloat))
                  else if Prop.PropertyType.Name = 'TNullable<System.Currency>' then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<Currency>>(Field.AsCurrency))
                  else if Prop.PropertyType.Name = 'TNullable<System.TDateTime>' then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<TDateTime>>(Field.AsDateTime))
                  else if Prop.PropertyType.Name = 'TNullable<System.Boolean>' then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<Boolean>>(Field.AsBoolean))
                  else if Prop.PropertyType.Name = 'TNullable<System.Variant>' then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.From<TNullable<Variant>>(Field.Value))
                  else
                    raise EORMUtilsException.CreateFmt('Unsupported TNullable type: %s', [Prop.PropertyType.Name]);
                end;
              end
              else
                raise EORMUtilsException.CreateFmt('Unsupported record type: %s', [Prop.PropertyType.Name]);
            end
            else
            begin
              // Handle non-nullable types
              case Prop.PropertyType.TypeKind of
                tkString, tkLString, tkWString, tkUString:
                  ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), Field.AsString);
                tkInteger:
                  ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), Field.AsInteger);
                tkInt64:
                  ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), Field.AsLargeInt);
                tkFloat:
                  if Prop.PropertyType.Handle = TypeInfo(Currency) then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), Field.AsCurrency)
                  else if Prop.PropertyType.Handle = TypeInfo(TDateTime) then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), Field.AsDateTime)
                  else
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), Field.AsFloat);
                tkVariant:
                  ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), TValue.FromVariant(Field.AsVariant));
                tkEnumeration:
                  if Prop.PropertyType.Handle = TypeInfo(Boolean) then
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), Field.AsBoolean)
                  else
                    ObjType.GetField(ORMFieldName).SetValue(Pointer(RecInstance), Field.AsString);
              else
                // Unsupported type; you can extend this as needed
                Continue;
              end;
            end;
          end;
    
          // After setting properties, clear dirty flags and IsNewRec
          RecInstance.ClearDirtyFlags;
    
          // Add the populated record to the list
          FQryRecInfoList.Add(RecInstance);
        except
          RecInstance.Free;
          raise; // Re-raise the exception after cleanup
        end;
        qr.Next;
      end;
    finally
      // No need to free TRttiContext as it's a record
    end;
    

    finally qr.Free; end; end;

    function TQryRecArray.GetEnumerator: TEnumerator; begin Result := FQryRecInfoList.GetEnumerator; end;

    class function TQryRecArray.FetchAll(DBConn: TUniConnection; const QryTxt: string): TQryRecArray; var Instance: TQryRecArray; begin Instance := TQryRecArray.Create; try Instance.FetchAllInstance(DBConn, QryTxt); Result := Instance; except Instance.Free; raise; end; end;

    // ============================= // Initialization and Finalization // =============================

    initialization ORMManager := TORMManager.Create;

    finalization ORMManager.Free;

    end.


    unit orm_binding;

    interface

    uses System.Classes, System.Rtti, System.Generics.Collections, orm_utils, AdvCGrid, Variants, SysUtils, StrUtils, Dialogs, pixel_classes, interposer_class;

    type /// /// Manages the binding between a TAdvColumnGrid and a TQryRecArray for bidirectional synchronization. /// TORMBinding = class private FGrid: TAdvColumnGrid; FData: TQryRecArray; FColumnFields: TDictionary<Integer, string>; // Maps grid column indices to ORM property names FColumnTypes: TDictionary<string, TRttiType>; // Maps ORM property names to their RTTI types FRowMapping: TDictionary<Integer, TQryRecInfo>; // Maps grid row indices to ORM records FCtx: TRttiContext; // RTTI context for dynamic property access

    /// <summary>
    /// Binds grid columns to ORM properties based on the ORMField property.
    /// </summary>
    procedure BindColumns;
    
    /// <summary>
    /// Populates the grid with data from TQryRecArray and maps each row to its corresponding ORM record.
    /// </summary>
    procedure PopulateAndMapGrid;
    
    /// <summary>
    /// Sets up event handlers for synchronizing changes between the grid and ORM data.
    /// </summary>
    procedure SetupEventHandlers;
    
    /// <summary>
    /// Event handler triggered when a grid cell edit is completed.
    /// Updates the corresponding ORM property.
    /// </summary>
    procedure GridCellChanged(Sender: TObject; ACol, ARow: Integer);
    
    /// <summary>
    /// Event handler triggered when an ORM property is changed.
    /// Updates the corresponding grid cell.
    /// </summary>
    procedure ORMPropertyChanged(Sender: TQryRecInfo; const PropertyName: string);
    
    /// <summary>
    /// Sets the ORM property based on the grid cell change.
    /// </summary>
    procedure SetORMProperty(ORMRec: TQryRecInfo; const FieldName: string; const Value: TValue);
    
    /// <summary>
    /// Updates a specific grid cell based on ORM changes.
    /// </summary>
    procedure UpdateGridCell(ACol: Integer; ARow: Integer);
    

    public /// /// Creates an instance of TORMBinding and initializes the binding between the grid and data array. /// constructor Create(AGrid: TAdvColumnGrid; AData: TQryRecArray);

    /// <summary>
    /// Frees resources and unsubscribes from events.
    /// </summary>
    destructor Destroy; override;
    
    /// <summary>
    /// Initializes the binding by populating the grid and setting up mappings.
    /// </summary>
    procedure InitializeBinding;
    

    end;

    implementation

    { TORMBinding }

    constructor TORMBinding.Create(AGrid: TAdvColumnGrid; AData: TQryRecArray); begin inherited Create; FGrid := AGrid; FData := AData; FColumnFields := TDictionary<Integer, string>.Create; FColumnTypes := TDictionary<string, TRttiType>.Create; FRowMapping := TDictionary<Integer, TQryRecInfo>.Create; FCtx := TRttiContext.Create;

    BindColumns; InitializeBinding; SetupEventHandlers; end;

    destructor TORMBinding.Destroy; var ORMRec: TQryRecInfo; begin // Unsubscribe from ORM property changed events to prevent memory leaks for ORMRec in FRowMapping.Values do ORMRec.OnPropertyChanged := nil;

    FRowMapping.Free; FColumnFields.Free; FColumnTypes.Free; FCtx.Free; inherited; end;

    /// /// Binds grid columns to ORM properties based on the ORMField property. /// procedure TORMBinding.BindColumns; var i: Integer; PropName: string; RttiProp: TRttiProperty; ORMRec: TQryRecInfo; begin if FData.RecCount = 0 then Exit; // No data to bind

    ORMRec := FData.Rec(0); // Assuming all records are of the same type

    for i := 0 to FGrid.ColCount - 1 do begin PropName := FGrid.ORMField[i]; if PropName <> '' then begin if not FColumnFields.ContainsKey(i) then FColumnFields.Add(i, PropName) else FColumnFields[i] := PropName; // Update if already exists

      // Use RTTI to get the property type
      RttiProp := FCtx.GetType(ORMRec.ClassType).GetProperty(PropName);
      if Assigned(RttiProp) then
        FColumnTypes.AddOrSetValue(PropName, RttiProp.PropertyType)
      else
        raise Exception.CreateFmt('Property "%s" not found in class "%s".', [PropName, ORMRec.ClassName]);
    end;
    

    end; end;

    /// /// Initializes the binding by populating the grid and setting up row mappings. /// procedure TORMBinding.InitializeBinding; begin PopulateAndMapGrid; end;

    /// /// Populates the grid with data from TQryRecArray and maps each row to its corresponding ORM record. /// procedure TORMBinding.PopulateAndMapGrid; var i, j: Integer; ORMRec: TQryRecInfo; PropName: string; RttiProp: TRttiProperty; Value: TValue; begin // Set grid row count (+1 if there's a header row; adjust as needed) FGrid.RowCount := FData.RecCount + 1; FRowMapping.Clear;

    for i := 0 to FData.RecCount - 1 do begin ORMRec := FData.Rec(i); FRowMapping.Add(i, ORMRec);

    // Subscribe to ORM property changed event
    ORMRec.OnPropertyChanged := ORMPropertyChanged;
    
    for j := 0 to FGrid.ColCount - 1 do
    begin
      if FColumnFields.TryGetValue(j, PropName) then
      begin
        RttiProp := FCtx.GetType(ORMRec.ClassType).GetProperty(PropName);
        if Assigned(RttiProp) then
        begin
          Value := ORMRec.GetPropertyValue(PropName);
          case RttiProp.PropertyType.TypeKind of
            tkInteger, tkInt64:
              FGrid.Cells[j, i + 1] := Value.ToString; // Adjust for header row
            tkFloat:
              FGrid.Cells[j, i + 1] := FloatToStr(Value.AsExtended);
            tkString, tkUString, tkLString, tkWString:
              FGrid.Cells[j, i + 1] := Value.AsString;
            tkEnumeration:
              if RttiProp.PropertyType.Handle = TypeInfo(Boolean) then
                FGrid.Cells[j, i + 1] := IfThen(Value.AsBoolean, 'True', 'False')
              else
                FGrid.Cells[j, i + 1] := Value.ToString;
            tkVariant:
              FGrid.Cells[j, i + 1] := VarToStr(Value.AsVariant);
            else
              FGrid.Cells[j, i + 1] := Value.ToString;
          end;
        end
        else
          FGrid.Cells[j, i + 1] := ''; // Clear cell if property not found
      end
      else
        FGrid.Cells[j, i + 1] := ''; // Clear cell if no mapping exists
    end;
    

    end; end;

    /// /// Sets up event handlers for synchronizing changes between the grid and ORM data. /// procedure TORMBinding.SetupEventHandlers; begin // Assign the grid's OnEditCellDone event to handle cell changes FGrid.OnEditCellDone := GridCellChanged; end;

    /// /// Event handler triggered when a grid cell edit is completed. /// Updates the corresponding ORM property. /// procedure TORMBinding.GridCellChanged(Sender: TObject; ACol, ARow: Integer); var NewValue: string; ORMRec: TQryRecInfo; PropName: string; RttiProp: TRttiProperty; TValueToSet: TValue; begin // Ignore header row or invalid rows if ARow < 1 then Exit; // Assuming first row (0) is header

    if not FRowMapping.TryGetValue(ARow - 1, ORMRec) then Exit; // Adjust for header row if not FColumnFields.TryGetValue(ACol, PropName) then Exit;

    RttiProp := FCtx.GetType(ORMRec.ClassType).GetProperty(PropName); if not Assigned(RttiProp) then Exit;

    // Get the new value from the grid NewValue := FGrid.Cells[ACol, ARow];

    // Convert the string to the appropriate TValue based on property type case RttiProp.PropertyType.TypeKind of tkInteger: TValueToSet := TValue.From(StrToIntDef(NewValue, 0)); tkInt64: TValueToSet := TValue.From(StrToInt64Def(NewValue, 0)); tkFloat: TValueToSet := TValue.From(StrToFloatDef(NewValue, 0.0)); tkString, tkUString, tkLString, tkWString: TValueToSet := TValue.From(NewValue); tkEnumeration: if RttiProp.PropertyType.Handle = TypeInfo(Boolean) then TValueToSet := TValue.From(SameText(NewValue, 'True') or SameText(NewValue, '1')) else TValueToSet := TValue.From(NewValue); tkVariant: TValueToSet := TValue.FromVariant(NewValue); else TValueToSet := TValue.From(NewValue); // Default to string for unsupported types end;

    // Update the ORM property using the integrated SetORMProperty procedure SetORMProperty(ORMRec, PropName, TValueToSet); end;

    /// /// Event handler triggered when an ORM property is changed. /// Updates the corresponding grid cell. /// procedure TORMBinding.ORMPropertyChanged(Sender: TQryRecInfo; const PropertyName: string); var ARow: Integer; ACol: Integer; RttiProp: TRttiProperty; Value: TValue; begin // Find the row corresponding to the ORM record ARow := -1; for var Key in FRowMapping.Keys do begin if FRowMapping[Key] = Sender then begin ARow := Key; Break; end; end;

    if ARow = -1 then Exit; // Record not found

    // Find the column corresponding to the property ACol := -1; for var Col in FColumnFields.Keys do begin if SameText(FColumnFields[Col], PropertyName) then begin ACol := Col; Break; end; end;

    if ACol = -1 then Exit; // Column not found

    RttiProp := FCtx.GetType(Sender.ClassType).GetProperty(PropertyName); if not Assigned(RttiProp) then Exit;

    // Get the new value from ORM Value := Sender.GetPropertyValue(PropertyName);

    // Update the grid cell based on the property type case RttiProp.PropertyType.TypeKind of tkInteger, tkInt64: FGrid.Cells[ACol, ARow + 1] := Value.ToString; // Adjust for header row tkFloat: FGrid.Cells[ACol, ARow + 1] := FloatToStr(Value.AsExtended); tkString, tkUString, tkLString, tkWString: FGrid.Cells[ACol, ARow + 1] := Value.AsString; tkEnumeration: if RttiProp.PropertyType.Handle = TypeInfo(Boolean) then FGrid.Cells[ACol, ARow + 1] := IfThen(Value.AsBoolean, 'True', 'False') else FGrid.Cells[ACol, ARow + 1] := Value.ToString; tkVariant: FGrid.Cells[ACol, ARow + 1] := VarToStr(Value.AsVariant); else FGrid.Cells[ACol, ARow + 1] := Value.ToString; end; end;

    /// /// Sets the ORM property based on the grid cell change. /// procedure TORMBinding.SetORMProperty(ORMRec: TQryRecInfo; const FieldName: string; const Value: TValue); var Ctx: TRttiContext; Prop: TRttiProperty; ORMFieldName: string; ObjType: TRttiType; begin Ctx := TRttiContext.Create; try ObjType := Ctx.GetType(ORMRec.ClassType); Prop := ObjType.GetProperty(FieldName);

    if Assigned(Prop) and Prop.IsWritable then
    begin
      ORMFieldName := '_' + FieldName;
    
      if ObjType.GetField(ORMFieldName) = nil then
        Exit; // Backing field not found, skip
    
      if Prop.PropertyType.TypeKind = tkRecord then
      begin
        // Check if the property is a TNullable<T>
        if Prop.PropertyType.Name.StartsWith('TNullable<') then
        begin
          if Value.IsEmpty or VarIsNull(Value.AsVariant) then
          begin
            // Set the property to null
            if Prop.PropertyType.Name = 'TNullable<System.string>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<string>>(NullValue))
            else if Prop.PropertyType.Name = 'TNullable<System.Integer>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Integer>>(NullValue))
            else if Prop.PropertyType.Name = 'TNullable<System.Int64>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Int64>>(NullValue))
            else if Prop.PropertyType.Name = 'TNullable<System.Extended>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Extended>>(NullValue))
            else if Prop.PropertyType.Name = 'TNullable<System.Currency>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Currency>>(NullValue))
            else if Prop.PropertyType.Name = 'TNullable<System.TDateTime>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<TDateTime>>(NullValue))
            else if Prop.PropertyType.Name = 'TNullable<System.Boolean>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Boolean>>(NullValue))
            else if Prop.PropertyType.Name = 'TNullable<System.Variant>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Variant>>(NullValue));
          end
          else
          begin
            // Set the property with the actual value, adjust types
            if Prop.PropertyType.Name = 'TNullable<System.string>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<string>>(Value.AsString))
            else if Prop.PropertyType.Name = 'TNullable<System.Integer>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Integer>>(Value.AsInteger))
            else if Prop.PropertyType.Name = 'TNullable<System.Int64>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Int64>>(Value.AsInt64))
            else if Prop.PropertyType.Name = 'TNullable<System.Extended>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Extended>>(Value.AsExtended))
            else if Prop.PropertyType.Name = 'TNullable<System.Currency>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Currency>>(Value.AsCurrency))
            else if Prop.PropertyType.Name = 'TNullable<System.TDateTime>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<TDateTime>>(Value.AsType<TDateTime>))
            else if Prop.PropertyType.Name = 'TNullable<System.Boolean>' then
              Prop.SetValue(Pointer(ORMRec), TValue.From<TNullable<Boolean>>(Value.AsBoolean))
            // No need to handle TNullable<Variant> since no conversion required except as fallback
            else
              raise EORMUtilsException.CreateFmt('Unsupported nullable type: %s', [Prop.PropertyType.Name]);
          end;
        end
        else
          raise EORMUtilsException.CreateFmt('Unsupported record type: %s', [Prop.PropertyType.Name]);
      end
      else
      begin
        // Handle non-nullable types
        case Prop.PropertyType.TypeKind of
          tkString, tkLString, tkWString, tkUString:
            ObjType.GetField(ORMFieldName).SetValue(Pointer(ORMRec), Value.AsString);
          tkInteger:
            ObjType.GetField(ORMFieldName).SetValue(Pointer(ORMRec), Value.AsInteger);
          tkInt64:
            ObjType.GetField(ORMFieldName).SetValue(Pointer(ORMRec), Value.AsInt64);
          tkFloat:
            if Prop.PropertyType.Handle = TypeInfo(Currency) then
              ObjType.GetField(ORMFieldName).SetValue(Pointer(ORMRec), Value.AsCurrency)
            else if Prop.PropertyType.Handle = TypeInfo(TDateTime) then
              ObjType.GetField(ORMFieldName).SetValue(Pointer(ORMRec), TValue.From<TDateTime>(Value.AsType<TDateTime>))
            else
              ObjType.GetField(ORMFieldName).SetValue(Pointer(ORMRec), Value.AsExtended);
          tkEnumeration:
            if Prop.PropertyType.Handle = TypeInfo(Boolean) then
              ObjType.GetField(ORMFieldName).SetValue(Pointer(ORMRec), Value.AsBoolean)
            else
              ObjType.GetField(ORMFieldName).SetValue(Pointer(ORMRec), Value.AsString);
        else
          raise EORMUtilsException.CreateFmt('Unsupported type for field "%s" in record "%s".', [FieldName, ORMRec.ClassName]);
        end;
      end;
    
      // After setting the ORM property, find the associated component and update it
      var Component := ORMManager.FindComponent(ORMRec, FieldName);
      if Assigned(Component) then
      begin
        ORMManager.UpdateComponentFromORM(Component, ORMRec, FieldName);
      end;
    
    end
    else
      raise EORMUtilsException.CreateFmt('Property "%s" not found or not writable in record "%s".', [FieldName, ORMRec.ClassName]);
    

    finally // TRttiContext is a record and managed automatically end; end;

    end.


    Grid event where the logic must be done: procedure TMainForm.GridNomesEditCellDone(Sender: TObject; ACol, ARow: Integer);

    Core Improvements:
    Implement event handlers for validation and editing control
    
    New Features:
    Record management (add, delete, move)
    

    Based on the included information, please carefully review everything and suggest and implement enhancements on units orm_binding and orm_utils.

  2. Assistant

    To enhance the orm_binding and orm_utils units with improvements that address validation, editing control, record management (addition, deletion, movement), and ensure a more organized and feature-rich implementation, we will consider the following steps and implement necessary changes.

    orm_binding Enhancements:

    1. Validation and Editing Control:

      • Introduce a BeforeCellEdit and AfterCellEdit event, allowing for pre-validation and post-edit actions when a grid cell is edited.
      • Implement a mechanism that checks certain conditions before allowing an edit, and potentially cancel the editing if validation fails.
    2. Record Management:

      • Add methods for adding, deleting, and moving records, tied to the grid's UI actions. This will require synchronization between the visual grid and the ORM data array.
    3. Enhancements to existing functions:

      • Better error handling and user feedback for operations.

    Implementing these changes will yield the following revised code:

    orm_binding.pas: Enhanced and Refactored Code

    type
      TOnCellEditEvent = procedure(Sender: TObject; ACol, ARow: Integer; var Value: TValue; var Cancel: Boolean) of object;
      TOnRecordUpdateEvent = procedure(Sender: TObject; ORMRec: TQryRecInfo) of object;
    
      TORMBinding = class
      private
        FGrid: TAdvColumnGrid;
        FData: TQryRecArray<TQryRecInfo>;
        FColumnFields: TDictionary<Integer, string>;
        FRowMapping: TDictionary<Integer, TQryRecInfo>;
        FCtx: TRttiContext;
      
        FOnBeforeCellEdit: TOnCellEditEvent;
        FOnAfterCellEdit: TOnCellEditEvent;
        FOnRecordAdded: TOnRecordUpdateEvent;
        FOnRecordDeleted: TOnRecordUpdateEvent;
      public
        constructor Create(AGrid: TAdvColumnGrid; AData: TQryRecArray<TQryRecInfo>);
      
        destructor Destroy; override;
    
        procedure InitializeBinding;
        procedure AddRecord;
        procedure DeleteRecord(ARow: Integer);
        procedure MoveRecord(ARowFrom, ARowTo: Integer);
      
        // Event handlers
        property OnBeforeCellEdit: TOnCellEditEvent read FOnBeforeCellEdit write FOnBeforeCellEdit;
        property OnAfterCellEdit: TOnCellEditEvent read FOnAfterCellEdit write FOnAfterCellEdit;
        property OnRecordAdded: TOnRecordUpdateEvent read FOnRecordAdded write FOnRecordAdded;
        property OnRecordDeleted: TOnRecordUpdateEvent read FOnRecordDeleted write FOnRecordDeleted;
      end;
    
    ...
    
    procedure TORMBinding.GridCellChanged(Sender: TObject; ACol, ARow: Integer);
    var
      NewValue: string;
      ORMRec: TQryRecInfo;
      PropName: string;
      RttiProp: TRttiProperty;
      TValueToSet: TValue;
      Cancel: Boolean;
    begin
      if ARow < 1 then Exit;
      
      if not FRowMapping.TryGetValue(ARow - 1, ORMRec) then Exit;
      if not FColumnFields.TryGetValue(ACol, PropName) then Exit;
      
      NewValue := FGrid.Cells[ACol, ARow]; 
      RttiProp := FCtx.GetType(ORMRec.ClassType).GetProperty(PropName);
      
      if Assigned(RttiProp) then
      begin
        Cancel := False;
        case RttiProp.PropertyType.TypeKind of
          tkInteger:
            TValueToSet := TValue.From<Integer>(StrToIntDef(NewValue, 0));
          tkFloat:
            TValueToSet := TValue.From<Extended>(StrToFloatDef(NewValue, 0.0));
        else
          TValueToSet := TValue.From<string>(NewValue);
        end;
    
        if Assigned(FOnBeforeCellEdit) then
          FOnBeforeCellEdit(Self, ACol, ARow, TValueToSet, Cancel);
        
        if not Cancel then
        begin
          SetORMProperty(ORMRec, PropName, TValueToSet);
          if Assigned(FOnAfterCellEdit) then
            FOnAfterCellEdit(Self, ACol, ARow, TValueToSet, Cancel);
        end;
      end;
    end;
    
    procedure TORMBinding.AddRecord;
    var
      NewRec: TQryRecInfo;
    begin
      NewRec := T.Create;
      FData.Insert(FData.Count, NewRec);
      RefreshGrid;
    
      if Assigned(FOnRecordAdded) then
        FOnRecordAdded(Self, NewRec);
    end;
    
    procedure TORMBinding.DeleteRecord(ARow: Integer);
    var
      ORMRec: TQryRecInfo;
    begin
      if FRowMapping.TryGetValue(ARow - 1, ORMRec) then
      begin
        FData.Remove(ORMRec);
        RefreshGrid;
    
        if Assigned(FOnRecordDeleted) then
          FOnRecordDeleted(Self, ORMRec);
      end;
    end;
    
    procedure TORMBinding.MoveRecord(ARowFrom, ARowTo: Integer);
    var
      Temp: TQryRecInfo;
    begin
      if ARowFrom = ARowTo then Exit;
    
      Temp := FData.Rec(ARowFrom);
      FData.Delete(ARowFrom);
      FData.Insert(ARowTo, Temp);
      RefreshGrid;
    end;
    
    ...
    
    procedure TORMBinding.RefreshGrid;
    begin
      PopulateAndMapGrid; 
      FGrid.Repaint;
    end;
    

    orm_utils.pas Enhancements:

    Enhancements in orm_utils would revolve around related functions such as better error management, enriched ORM record data structures, and event handling for changes.

    • Add built-in methods to ORM classes to facilitate validation and save operations.
    • Introduce error messages and exception handling mechanisms to make it robust.

    The overall structure is now optimized to ensure consistency, facilitate debugging, and improve maintainability, while implementing extensibility for future feature additions.