uGetItListModel.pas

unit uGetItListModel;

interface

uses
  System.Generics.Collections,
  uGetItTypes;

type
  TGetItListModel = record
  public
    class function IsDelphiPackage(const Pkg: TGetItPackageInfo): Boolean; static;
    class function BuildPackageGroupKey(const Pkg: TGetItPackageInfo): string; static;
    class function ComparePackageDate(const Left, Right: TGetItPackageInfo): Integer; static;
    class function ShouldIncludeByInstallStateFilter(const Pkg: TGetItPackageInfo;
      const InstalledOnly, NotInstalledOnly, UpdatableOnly: Boolean): Boolean; static;
    class procedure CountVersionStatusForVisible(const VisiblePackages: TList<TGetItPackageInfo>;
      out InstalledCount, OutdatedCount, ModifiedCount, UnavailableCount: Integer); static;
    class procedure UpdateVersionStatus(
      const AllPackages: TObjectDictionary<string, TGetItPackageInfo>;
      const InstalledPackages: TObjectDictionary<string, TInstalledGetItPackageInfo>); static;
  end;

implementation

uses
  System.SysUtils, System.DateUtils, uGetItCore;

function HasComparableFileValue(const Value: string): Boolean;
var
  Text: string;
begin
  Text := Trim(Value);
  Result := (Text <> '') and (not SameText(Text, 'NA'));
end;

function IsRemotePackageUrl(const Value: string): Boolean;
begin
  Result := SameText(Copy(Trim(Value), 1, 7), 'http://') or
    SameText(Copy(Trim(Value), 1, 8), 'https://');
end;

function TryNormalizePackageSize(const Value: string; out SizeValue: Int64): Boolean;
var
  FloatValue: Double;
  FormatSettings: TFormatSettings;
begin
  Result := TryStrToInt64(Trim(Value), SizeValue);
  if Result then
    Exit;

  FormatSettings := TFormatSettings.Invariant;
  if TryStrToFloat(Trim(Value), FloatValue, FormatSettings) or TryStrToFloat(Trim(Value), FloatValue) then
  begin
    SizeValue := Round(FloatValue);
    Exit(True);
  end;

  SizeValue := 0;
  Result := False;
end;

function PackageFileChanged(const Pkg: TGetItPackageInfo; const Installed: TInstalledGetItPackageInfo): Boolean;
var
  CatalogSize: Int64;
  InstalledSize: Int64;
begin
  Result := False;

  // A local import changes the source path, not necessarily the archive contents.
  if IsRemotePackageUrl(Pkg.LibUrl) and IsRemotePackageUrl(Installed.Url) and
     (not SameText(Trim(Pkg.LibUrl), Trim(Installed.Url))) then
    Exit(True);

  if HasComparableFileValue(Pkg.LibSize) and HasComparableFileValue(Installed.LibSize) and
     TryNormalizePackageSize(Pkg.LibSize, CatalogSize) and
     TryNormalizePackageSize(Installed.LibSize, InstalledSize) and
     (CatalogSize > 0) and (InstalledSize > 0) and
     (CatalogSize <> InstalledSize) then
    Exit(True);

  if HasComparableFileValue(Pkg.LibMD5) and HasComparableFileValue(Installed.LibMD5) and
     (not SameText(Trim(Pkg.LibMD5), Trim(Installed.LibMD5))) then
    Exit(True);
end;

procedure ApplyInstalledMetadata(const Pkg: TGetItPackageInfo; const Installed: TInstalledGetItPackageInfo);
begin
  Pkg.InstalledVersion := Installed.Version;
  Pkg.InstalledUrl := Installed.Url;
  Pkg.InstalledModified := Installed.Modified;
  Pkg.InstalledVersionTimestamp := Installed.VersionTimestamp;
  Pkg.InstalledLibSize := Installed.LibSize;
  Pkg.InstalledLibMD5 := Installed.LibMD5;
  Pkg.InstalledState := Installed.State;
  Pkg.InstalledAllUsers := Installed.AllUsers;
  Pkg.InstalledSubscription := Installed.Subscription;
end;

class function TGetItListModel.IsDelphiPackage(const Pkg: TGetItPackageInfo): Boolean;
var
  CodeValue: Integer;
  CodeName: string;
  IdText: string;
  NameText: string;
begin
  if TryStrToInt(Trim(Pkg.LibCode), CodeValue) then
  begin
    if CodeValue = 2 then
      Exit(False);
    if (CodeValue = 1) or (CodeValue = 5) then
      Exit(True);
  end;

  CodeName := Trim(LowerCase(Pkg.LibCodeName));
  if CodeName <> '' then
  begin
    if Pos('cplusplusbuilder', CodeName) > 0 then
      Exit(False);
    if (Pos('delphi', CodeName) > 0) or (Pos('allpersonalities', CodeName) > 0) then
      Exit(True);
  end;

  IdText := LowerCase(Pkg.Id + ' ' + Pkg.PackageId);
  NameText := LowerCase(Pkg.Name);
  if (Pos('-cb-', IdText) > 0) or IdText.EndsWith('-cb') or
     (Pos('cb-', IdText) > 0) or (Pos('(c++)', NameText) > 0) then
    Exit(False);

  Result := True;
end;

class function TGetItListModel.BuildPackageGroupKey(const Pkg: TGetItPackageInfo): string;
var
  BaseKey: string;
  LibCodeKey: string;
begin
  BaseKey := Trim(LowerCase(Pkg.Name));
  if BaseKey = '' then
    BaseKey := Trim(LowerCase(Pkg.Id));

  LibCodeKey := Trim(LowerCase(Pkg.LibCode));
  if LibCodeKey = '' then
    LibCodeKey := Trim(LowerCase(Pkg.LibCodeName));

  Result := BaseKey + '|' + Trim(LowerCase(Pkg.Vendor)) + '|' + LibCodeKey;
end;

class function TGetItListModel.ComparePackageDate(const Left, Right: TGetItPackageInfo): Integer;
var
  LeftDate, RightDate: TDateTime;
  LeftDateStr, RightDateStr: string;
begin
  LeftDateStr := Trim(Left.VersionTimestamp);
  if LeftDateStr = '' then
    LeftDateStr := Trim(Left.Modified);
  RightDateStr := Trim(Right.VersionTimestamp);
  if RightDateStr = '' then
    RightDateStr := Trim(Right.Modified);

  if TryISO8601ToDate(LeftDateStr, LeftDate) and TryISO8601ToDate(RightDateStr, RightDate) then
  begin
    if LeftDate > RightDate then
      Exit(-1);
    if LeftDate < RightDate then
      Exit(1);
    Exit(0);
  end;

  if TryStrToDateTime(LeftDateStr, LeftDate) and TryStrToDateTime(RightDateStr, RightDate) then
  begin
    if LeftDate > RightDate then
      Exit(-1);
    if LeftDate < RightDate then
      Exit(1);
    Exit(0);
  end;

  Result := TGetItCore.CompareVersionText(Right.Version, Left.Version);
end;

class function TGetItListModel.ShouldIncludeByInstallStateFilter(const Pkg: TGetItPackageInfo;
  const InstalledOnly, NotInstalledOnly, UpdatableOnly: Boolean): Boolean;
begin
  if UpdatableOnly then
    Exit(not Pkg.Incompatible and (Pkg.InstalledVersion <> '') and
      (SameText(Pkg.VersionStatus, 'Modified') or
       (SameText(Pkg.VersionStatus, 'Outdated') and
        (TGetItCore.CompareVersionText(Pkg.Version, Pkg.InstalledVersion) > 0))));
  if InstalledOnly then
    Exit(Pkg.InstalledVersion <> '');
  if NotInstalledOnly then
    Exit(Pkg.InstalledVersion = '');
  Result := True;
end;

class procedure TGetItListModel.CountVersionStatusForVisible(const VisiblePackages: TList<TGetItPackageInfo>;
  out InstalledCount, OutdatedCount, ModifiedCount, UnavailableCount: Integer);
begin
  InstalledCount := 0;
  OutdatedCount := 0;
  ModifiedCount := 0;
  UnavailableCount := 0;

  for var Pkg in VisiblePackages do
  begin
    if SameText(Pkg.VersionStatus, 'Outdated') then
    begin
      Inc(InstalledCount);
      Inc(OutdatedCount);
    end
    else if SameText(Pkg.VersionStatus, 'Modified') then
    begin
      Inc(InstalledCount);
      Inc(ModifiedCount);
    end
    else if SameText(Pkg.VersionStatus, 'Unavailable') then
    begin
      Inc(InstalledCount);
      Inc(UnavailableCount);
    end
    else if SameText(Pkg.VersionStatus, 'Installed') then
      Inc(InstalledCount);
  end;
end;

class procedure TGetItListModel.UpdateVersionStatus(
  const AllPackages: TObjectDictionary<string, TGetItPackageInfo>;
  const InstalledPackages: TObjectDictionary<string, TInstalledGetItPackageInfo>);
var
  LatestRepo: TDictionary<string, string>;
  IdIndex: TDictionary<string, TGetItPackageInfo>;
  InstalledByGroup: TDictionary<string, TInstalledGetItPackageInfo>;
  Key, LatestVersion: string;
  InstalledPkg, Pkg: TGetItPackageInfo;
  InstalledInfo, CurrentInstalled: TInstalledGetItPackageInfo;
  IsInstalledById: Boolean;
begin
  LatestRepo := TDictionary<string, string>.Create;
  IdIndex := TDictionary<string, TGetItPackageInfo>.Create;
  InstalledByGroup := TDictionary<string, TInstalledGetItPackageInfo>.Create;
  try
    for Pkg in AllPackages.Values do
    begin
      IdIndex.AddOrSetValue(Trim(LowerCase(Pkg.Id)), Pkg);
      if Pkg.CatalogUnavailable or (irBuild in Pkg.IncompatibilityReasons) then
        Continue;
      Key := BuildPackageGroupKey(Pkg);
      if not LatestRepo.TryGetValue(Key, LatestVersion) or
         (TGetItCore.CompareVersionText(LatestVersion, Pkg.Version) < 0) then
        LatestRepo.AddOrSetValue(Key, Pkg.Version);
    end;

    for var InstalledPair in InstalledPackages do
      if IdIndex.TryGetValue(InstalledPair.Key, InstalledPkg) then
      begin
        Key := BuildPackageGroupKey(InstalledPkg);
        if not InstalledByGroup.TryGetValue(Key, CurrentInstalled) or
           (TGetItCore.CompareVersionText(CurrentInstalled.Version, InstalledPair.Value.Version) < 0) then
          InstalledByGroup.AddOrSetValue(Key, InstalledPair.Value);
      end;

    for Pkg in AllPackages.Values do
    begin
      Pkg.ClearInstalledMetadata;
      Key := BuildPackageGroupKey(Pkg);
      if LatestRepo.TryGetValue(Key, LatestVersion) then
        Pkg.LatestVersion := LatestVersion
      else
        Pkg.LatestVersion := Pkg.Version;

      IsInstalledById := InstalledPackages.TryGetValue(Trim(LowerCase(Pkg.Id)), InstalledInfo);
      if not InstalledByGroup.TryGetValue(Key, CurrentInstalled) then
        CurrentInstalled := InstalledInfo;
      if CurrentInstalled = nil then
      begin
        Pkg.VersionStatus := 'NotInstalled';
        Continue;
      end;
      ApplyInstalledMetadata(Pkg, CurrentInstalled);
      if Pkg.CatalogUnavailable and IsInstalledById then
        Pkg.VersionStatus := 'Unavailable'
      else if TGetItCore.CompareVersionText(Pkg.InstalledVersion, Pkg.LatestVersion) < 0 then
        Pkg.VersionStatus := 'Outdated'
      else if IsInstalledById and
              (TGetItCore.CompareVersionText(Pkg.Version, Pkg.InstalledVersion) = 0) and
              PackageFileChanged(Pkg, CurrentInstalled) then
        Pkg.VersionStatus := 'Modified'
      else
        Pkg.VersionStatus := 'Installed';
    end;
  finally
    InstalledByGroup.Free;
    IdIndex.Free;
    LatestRepo.Free;
  end;
end;

end.