unit SUBaseFilter interface uses System Generics Collections SUBaseObj

unit SUBaseFilter;

interface
  uses
    System.Generics.Collections, SUBaseObject, SuBaseProperty;

  Type

    PBaseClilocFilter = class
      private
        m_ClilocID : Cardinal;
        m_State    : Boolean;
      public
        function Compare(Properties:PBaseProperty):Boolean;
        Constructor Create;

        class function Generate(SClilocID:Cardinal;SState:Boolean):PBaseClilocFilter;

        property ClilocID : Cardinal  read m_ClilocID write m_ClilocID;
        property State    : Boolean   read m_State    write m_State;
    end;

    PBasePropertyFilter = class
      private
        m_ClilocID    : Cardinal;
        m_Param       : Integer;
        m_ReqValue    : Integer;
        m_Comperator  : String;
      public
        function Compare(Properties:PBaseProperty):Boolean;
        Constructor Create;

        class function Generate(SClilocID:Cardinal;SParam,SValue:Integer;SComperator:String):PBasePropertyFilter;

        property ClilocID   : Cardinal  read m_ClilocID   write m_ClilocID;
        property Param      : Integer   read m_Param      write m_Param;
        property ReqValue   : Integer   read m_ReqValue   write m_ReqValue;
        property Comperator : String    read m_Comperator write m_Comperator;
    end;

    PBaseTextFilter = class
      private
        m_ClilocID : Cardinal;
        m_Param    : Integer;
        m_ReqValue : String;
        m_Explizit : Integer;
      public
        function Compare(Properties:PBaseProperty):Boolean;
        Constructor Create;

        class function Generate(SClilocID: Cardinal; SParam:Integer;SValue:String;SExplit: Integer): PBaseTextFilter;

        property ClilocID   : Cardinal  read m_ClilocID   write m_ClilocID;
        property Param      : Integer   read m_Param      write m_Param;
        property ReqValue   : String    read m_ReqValue   write m_ReqValue;
        property Explizit   : Integer   read m_Explizit   write m_Explizit;

    end;

    PBaseFilterEngine = class
      private
        m_ClilocFilter        : TList<PBaseClilocFilter>;
        m_BasePropertyFilter  : TList<PBasePropertyFilter>;
        m_BaseTextFilter      : TList<PBaseTextFilter>;
      public
        function Analyse(Obj:PBaseObject):Boolean;
        Constructor Create;

        property ClilocFilter        : TList<PBaseClilocFilter>    read m_ClilocFilter        write m_ClilocFilter;
        property BasePropertyFilter  : TList<PBasePropertyFilter>  read m_BasePropertyFilter  write m_BasePropertyFilter;
        property BaseTextFilter      : TList<PBaseTextFilter>      read m_BaseTextFilter      write m_BaseTextFilter;

    end;

implementation
  uses
    SysUtils;

{ PBaseFilterEngine }

function PBaseFilterEngine.Analyse(Obj: PBaseObject): Boolean;
var
  ergebnis : Boolean;
  i        : Integer;
begin
  ergebnis := True;

  if(ergebnis)then
  begin
    for i := 0 to (m_ClilocFilter.Count - 1) do
    begin
      if(ergebnis) then ergebnis := m_ClilocFilter[i].Compare(Obj.Properties);
    end;
  end;
  if(ergebnis)then
  begin
    for i := 0 to (m_BasePropertyFilter.Count - 1) do
    begin
      if(ergebnis) then ergebnis := m_BasePropertyFilter[i].Compare(Obj.Properties);
    end;
  end;
  if(ergebnis)then
  begin
    for i := 0 to (m_BaseTextFilter.Count - 1) do
    begin
      if(ergebnis) then ergebnis := m_BaseTextFilter[i].Compare(Obj.Properties);
    end;
  end;

  Result := ergebnis;
end;

constructor PBaseFilterEngine.Create;
begin
  m_ClilocFilter := TList<PBaseClilocFilter>.Create;
  m_BasePropertyFilter := TList<PBasePropertyFilter>.Create;
  m_BaseTextFilter := TList<PBaseTextFilter>.Create;
end;

{ PBaseClilocFilter }

function PBaseClilocFilter.Compare(Properties: PBaseProperty): Boolean;
begin
  Result := (Properties.Contains(ClilocID) = State);
end;

constructor PBaseClilocFilter.Create;
begin
  m_ClilocID := 0;
  m_State := False;
end;

class function PBaseClilocFilter.Generate(SClilocID: Cardinal; SState: Boolean): PBaseClilocFilter;
begin
  Result := PBaseClilocFilter.Create;
  Result.ClilocID := SClilocID;
  Result.State := SState;
end;

{ PBasePropertyFilter }

function PBasePropertyFilter.Compare(Properties: PBaseProperty): Boolean;
var
  P     : TList<String>;
  val   : Variant;
  rval  : Integer;
begin
  Result := False;

  if(Properties.Contains(ClilocID))then
  begin
    P := Properties.GetParams(ClilocID);
    if(Param < P.Count) and ( Param > -1)then
    begin
      val := P[Param];
      try
        rval := val;
      except
        exit;
      end;
      if(Comperator = '>')then
      begin
        Result := rval > ReqValue;
      end else if(Comperator = '>=')then
      begin
        Result := rval >= ReqValue;
      end else if(Comperator = '=')then
      begin
        Result := rval = ReqValue;
      end else if(Comperator = '<>')then
      begin
        Result := rval <> ReqValue;
      end else if(Comperator = '<=')then
      begin
        Result := rval <= ReqValue;
      end else if(Comperator = '<')then
      begin
        Result := rval < ReqValue;
      end;
    end;
  end;
end;

constructor PBasePropertyFilter.Create;
begin
  m_ClilocID := 0;
  m_Param := 0;
  m_ReqValue := 0;
  m_Comperator := '=';
end;

class function PBasePropertyFilter.Generate(SClilocID: Cardinal; SParam, SValue: Integer; SComperator: String): PBasePropertyFilter;
begin
  Result := PBasePropertyFilter.Create();
  Result.ClilocID := SClilocID;
  Result.Param := SParam;
  Result.ReqValue := SValue;
  Result.Comperator := SComperator;
end;

{ PBaseTextFilter }

function PBaseTextFilter.Compare(Properties: PBaseProperty): Boolean;
var
  P     : TList<String>;
  val   : String;
begin
  Result := False;
  if(Properties.Contains(ClilocID))then
  begin
    P := Properties.GetParams(ClilocID);
    if(Param < P.Count) and ( Param > -1)then
    begin
      val := P[Param];
      if(Explizit = -2)then
      begin
        Result := UpperCase(val) = UpperCase(ReqValue);
      end else if(Explizit = -1)then
      begin
        Result := val = ReqValue;
      end else if(Explizit = 1)then
      begin
        Result := Pos(val,ReqValue,0)> 0;
      end else if(Explizit = 2)then
      begin
        Result := Pos(UpperCase(val),UpperCase(ReqValue),0)> 0;
      end;
    end;
  end;
end;

constructor PBaseTextFilter.Create;
begin
  m_ClilocID := 0;
  m_Param := 0;
  m_ReqValue := '';
  m_Explizit := 0;
end;

class function PBaseTextFilter.Generate(SClilocID: Cardinal; SParam:Integer;SValue:String;SExplit: Integer): PBaseTextFilter;
begin
  Result := PBaseTextFilter.Create();
  Result.ClilocID := SClilocID;
  Result.Param := SParam;
  Result.ReqValue := SValue;
  Result.Explizit := SExplit;
end;

end.