uGetItRestService.pas

unit uGetItRestService;

interface

uses
  System.Classes, System.SysUtils, System.Generics.Collections, System.JSON,
  System.Net.HttpClient, uGetItTypes;

type
  EGetItDownloadError = class(Exception);
  EGetItCatalogError = class(Exception);

  TGetItRestRequest = record
    ServiceUrl: string;
    CatalogVersion: string;
    ProductId: string;
    ProductSku: string;
    IDEVersion: string;
    BuildNumber: string;
    InstalledPersonalities: TGetItPersonalities;
    SearchText: string;
  end;

  TGetItRestLogProc = reference to procedure(const Msg: string);

  TGetItRestService = record
  public
    class function FormatCatalogDetails(const Json: string): string; static;
    class function FetchResource(const Url: string): IHTTPResponse; static;
    class function DownloadFileName(const Url: string): string; static;
    class function DownloadLocalPackage(const Request: TGetItRestRequest;
      const PackageId, ParentDirectory: string): string; static;
    class procedure DownloadFile(const Url, TargetFile: string; const ReplaceExisting: Boolean); static;
    class function CatalogInfoUrl(const ServiceUrl: string): string; static;
    class function CatalogInfoByIdsUrl(const ServiceUrl: string): string; static;
    class procedure FetchPackages(const Request: TGetItRestRequest;
      const Target: TObjectDictionary<string, TGetItPackageInfo>;
      const OnLog: TGetItRestLogProc); static;
    class procedure FetchPackagesByIds(const Request: TGetItRestRequest; const Ids: TStrings;
      const Target: TObjectDictionary<string, TGetItPackageInfo>;
      const OnLog: TGetItRestLogProc); static;
  private
    class procedure FetchCatalog(const Request: TGetItRestRequest; const BuildNumber: string;
      const Target: TObjectDictionary<string, TGetItPackageInfo>; const OnLog: TGetItRestLogProc); static;
    class function BuildRestBody(const Request: TGetItRestRequest; const BuildNumber: string; const StartIndex, EndIndex: Integer): string; static;
    class function BuildInfoByIdsBody(const Request: TGetItRestRequest; const IdList: string): string; static;
    class function JsonValueToString(const Obj: TJSONObject; const Name: string): string; static;
    class function ReadPackage(const Obj: TJSONObject): TGetItPackageInfo; static;
    class function ReadTargets(const Obj: TJSONObject; const Field: string): TArray<TGetItNamedId>; static;
    class procedure AddJsonPackages(const Arr: TJSONArray;
      const Target: TObjectDictionary<string, TGetItPackageInfo>; const CatalogUnavailable: Boolean); static;
    class procedure ReadCategories(const Obj: TJSONObject; out CategoryIds, CategoryNames: string); static;
    class function TryGetArrayFromPayload(const JsonRoot: TJSONValue; out Arr: TJSONArray): Boolean; static;
    class function ResponsePreview(const Content: string; const MaxLen: Integer = 240): string; static;
  end;

implementation

uses
  Winapi.Windows, System.IOUtils, System.Net.URLClient, System.NetEncoding, System.StrUtils,
  uGetItCore;


class function TGetItRestService.FormatCatalogDetails(const Json: string): string;
var
  Root: TJSONValue;
  Lines: TStringList;
  procedure AppendValue(const Name: string; const Value: TJSONValue; const Indent: string);
  var
    Item, IdValue, NameValue: TJSONValue;
  begin
    if Value is TJSONObject then
    begin
      if Name <> '' then
        Lines.Add(Indent + Name + ':');
      for var Pair in TJSONObject(Value) do
        AppendValue(Pair.JsonString.Value, Pair.JsonValue, Indent + '  ');
    end
    else if Value is TJSONArray then
    begin
      Lines.Add(Indent + Name + ':');
      for var i := 0 to TJSONArray(Value).Count - 1 do
      begin
        Item := TJSONArray(Value).Items[i];
        if MatchText(Name, ['Categories', 'LibPlatforms', 'LibOSes']) and
           (Item is TJSONObject) and (TJSONObject(Item).Count = 2) then
        begin
          IdValue := TJSONObject(Item).GetValue('Id');
          NameValue := TJSONObject(Item).GetValue('Name');
          if (IdValue <> nil) and (NameValue <> nil) then
          begin
            Lines.Add(IdValue.Value + ', ' + NameValue.Value);
            Continue;
          end;
        end;
        AppendValue(IntToStr(i + 1), Item, Indent + '  ');
      end;
    end
    else
      Lines.Add(Indent + Name + ': ' + Value.Value);
  end;
begin
  Result := '';
  if Json = '' then
    Exit;
  Root := TJSONObject.ParseJSONValue(Json, False, True);
  try
    Lines := TStringList.Create;
    try
      for var Pair in Root as TJSONObject do
        if not MatchText(Pair.JsonString.Value,
          ['Image', 'Icon', 'LibLicense', 'LibUrl', 'LibProjectUrl']) then
          AppendValue(Pair.JsonString.Value, Pair.JsonValue, '');
      Result := Lines.Text;
    finally
      Lines.Free;
    end;
  finally
    Root.Free;
  end;
end;

class function TGetItRestService.FetchResource(const Url: string): IHTTPResponse;
var
  Client: THTTPClient;
begin
  if not (Url.StartsWith('https://', True) or Url.StartsWith('http://', True)) then
    raise EGetItDownloadError.Create('Only HTTP/HTTPS resource links are supported.');
  Client := THTTPClient.Create;
  try
    Client.ConnectionTimeout := 2000;
    Client.ResponseTimeout := 5000;
    Result := Client.Get(Url);
    if Result.StatusCode <> 200 then
      raise EGetItDownloadError.CreateFmt('Resource download failed with HTTP status %d.', [Result.StatusCode]);
    if (Result.ContentLength >= 0) and (Result.ContentStream.Size <> Result.ContentLength) then
      raise EGetItDownloadError.Create('The downloaded resource is incomplete.');
  finally
    Client.Free;
  end;
end;

class function TGetItRestService.DownloadFileName(const Url: string): string;
begin
  Result := TNetEncoding.URL.Decode(TPath.GetFileName(TURI.Create(Url).Path).Replace('+', '%2B'));
  if (Result = '') or Result.EndsWith('.') or Result.EndsWith(' ') then
    raise EArgumentException.Create('The download URL has no valid file name.');
  for var Ch in Result do
    if CharInSet(Ch, [#0..#31, '<', '>', ':', '"', '/', '\', '|', '?', '*']) then
      raise EArgumentException.Create('The download URL contains an invalid file name.');
end;

class procedure TGetItRestService.DownloadFile(const Url, TargetFile: string; const ReplaceExisting: Boolean);
var
  HttpClient: THTTPClient;
  Response: IHTTPResponse;
  Stream: THandleStream;
  TempFile: string;
  FileId: TGUID;
  FileHandle: THandle;
  MoveFlags: DWORD;
begin
  CreateGUID(FileId);
  TempFile := TPath.Combine(ExtractFilePath(TargetFile), '.getit-' + GUIDToString(FileId) + '.part');
  HttpClient := THTTPClient.Create;
  try
    FileHandle := CreateFile(PChar(TempFile), GENERIC_WRITE, 0, nil, CREATE_NEW,
      FILE_ATTRIBUTE_NORMAL, 0);
    if FileHandle = INVALID_HANDLE_VALUE then
      RaiseLastOSError;
    // Only this newly created file is removed on failure. The destination is untouched.
    try
      try
        Stream := THandleStream.Create(FileHandle);
        try
          Response := HttpClient.Get(Url, Stream);
          if Response.StatusCode <> 200 then
            raise EGetItDownloadError.CreateFmt('Download failed with HTTP status %d.', [Response.StatusCode]);
          if (Response.ContentLength >= 0) and (Stream.Size <> Response.ContentLength) then
            raise EGetItDownloadError.Create('The downloaded file is incomplete.');
        finally
          Stream.Free;
        end;
      finally
        CloseHandle(FileHandle);
      end;
      MoveFlags := MOVEFILE_WRITE_THROUGH;
      if ReplaceExisting then
        MoveFlags := MoveFlags or MOVEFILE_REPLACE_EXISTING;
      if not MoveFileEx(PChar(TempFile), PChar(TargetFile), MoveFlags) then
        RaiseLastOSError;
    finally
      if FileExists(TempFile) then
        TFile.Delete(TempFile);
    end;
  finally
    HttpClient.Free;
  end;
end;

class function TGetItRestService.DownloadLocalPackage(const Request: TGetItRestRequest;
  const PackageId, ParentDirectory: string): string;
var
  Packages: TObjectDictionary<string, TGetItPackageInfo>;
  Ids: TStringList;
  Pkg: TGetItPackageInfo;
  Manifest: TJSONObject;
  Root: TJSONValue;
  StageDir, FileName, ArchiveExt: string;
  StageId: TGUID;

  function FieldText(const Name: string): string;
  var
    Value: TJSONValue;
  begin
    Value := Manifest.GetValue(Name);
    if (Value = nil) or (Value is TJSONNull) then
      Exit('');
    if not (Value is TJSONString) then
      raise EGetItCatalogError.Create('Invalid package field: ' + Name);
    Result := Value.Value;
  end;

  procedure SetText(const Name, Value: string);
  begin
    Manifest.RemovePair(Name).Free;
    Manifest.AddPair(Name, Value);
  end;

  procedure DownloadResource(const SourceField, LocalField, Prefix: string;
    const Required: Boolean);
  var
    Url, LocalName: string;
  begin
    Url := FieldText(SourceField);
    if Url = '' then
    begin
      if Required then
        raise EGetItCatalogError.Create('Missing package field: ' + SourceField);
      Exit;
    end;
    if not (StartsText('https://', Url) or StartsText('http://', Url)) then
      raise EGetItCatalogError.Create('Expected HTTP resource: ' + SourceField);
    LocalName := Prefix + DownloadFileName(Url);
    DownloadFile(Url, TPath.Combine(StageDir, LocalName), False);
    SetText(LocalField, LocalName);
  end;

begin
  if (PackageId = '') or (PackageId <> Trim(PackageId)) then
    raise EArgumentException.Create('Invalid package directory name.');
  for var Ch in PackageId do
    if CharInSet(Ch, ['<', '>', ':', '"', '/', '\', '|', '?', '*']) or (Ord(Ch) < 32) then
      raise EArgumentException.Create('Invalid package directory name.');
  if PackageId.EndsWith('.') then
    raise EArgumentException.Create('Invalid package directory name.');
  Result := TPath.Combine(TPath.GetFullPath(ParentDirectory), 'GetIt-' + PackageId);
  if TDirectory.Exists(Result) or TFile.Exists(Result) then
    raise EGetItDownloadError.Create('Destination already exists: ' + Result);
  if not TDirectory.Exists(ParentDirectory) then
    raise EGetItDownloadError.Create('Destination parent directory does not exist.');

  Packages := TObjectDictionary<string, TGetItPackageInfo>.Create([doOwnsValues]);
  try
    Ids := TStringList.Create;
    try
      Ids.Add(PackageId);
      FetchPackagesByIds(Request, Ids, Packages, nil);
    finally
      Ids.Free;
    end;
    if not Packages.TryGetValue(PackageId, Pkg) then
      raise EGetItCatalogError.Create('Package not returned by infobyids: ' + PackageId);
    ArchiveExt := TPath.GetExtension(DownloadFileName(Pkg.LibUrl));
    if not MatchText(ArchiveExt, ['.zip', '.7z']) then
      raise EGetItCatalogError.Create('Local GetIt import requires a ZIP or 7z archive.');
    Root := TJSONObject.ParseJSONValue(Pkg.CatalogDetailsJson);
    try
      if not (Root is TJSONObject) then
        raise EGetItCatalogError.Create('Invalid package JSON.');
      Manifest := TJSONObject(Root);
      if not (Manifest.GetValue('Actions') is TJSONArray) then
        raise EGetItCatalogError.Create('The server did not provide an Actions array.');
      CreateGUID(StageId);
      StageDir := TPath.Combine(TPath.GetFullPath(ParentDirectory),
        '.getit-' + GUIDToString(StageId) + '.partial');
      if not CreateDirectory(PChar(StageDir), nil) then
        RaiseLastOSError;
      try
        // Preserve all metadata and actions in the manifest, mapping local resource fields.
        DownloadResource('LibUrl', 'Url', 'archive-', True);
        DownloadResource('LibLicense', 'License', 'license-', True);
        DownloadResource('Image', 'Image', 'image-', False);
        DownloadResource('Icon', 'Icon', 'icon-', False);
        SetText('LicenseName', FieldText('LibLicenseName'));
        SetText('ProjectUrl', FieldText('LibProjectUrl'));
        TFile.WriteAllText(TPath.Combine(StageDir, 'package.json'),
          Manifest.ToJSON, TEncoding.UTF8);
        TFile.WriteAllText(TPath.Combine(StageDir, 'README.txt'),
          'Open package.json using GetIt / Load Local Package in the matching RAD Studio version.' +
          sLineBreak + 'The archive and actions are unchanged. Actions or dependencies may require' +
          sLineBreak + 'additional downloads; this bundle does not guarantee a fully offline installation.' +
          sLineBreak + 'GetIt may show 1 Jan 2000 for a local installation despite the original timestamp.' +
          sLineBreak, TEncoding.UTF8);
        TDirectory.Move(StageDir, Result);
      finally
        // Only the newly created, flat staging directory belongs to this operation.
        if TDirectory.Exists(StageDir) then
        begin
          for FileName in TDirectory.GetFiles(StageDir) do
            TFile.Delete(FileName);
          TDirectory.Delete(StageDir, False);
        end;
      end;
    finally
      Root.Free;
    end;
  finally
    Packages.Free;
  end;
end;

class function TGetItRestService.CatalogInfoUrl(const ServiceUrl: string): string;
var
  BaseUrl: string;
begin
  BaseUrl := Trim(ServiceUrl);
  if BaseUrl.EndsWith('/') then
    Result := BaseUrl + 'catalog/info'
  else
    Result := BaseUrl + '/catalog/info';
end;

class function TGetItRestService.CatalogInfoByIdsUrl(const ServiceUrl: string): string;
var
  BaseUrl: string;
begin
  BaseUrl := Trim(ServiceUrl);
  if BaseUrl.EndsWith('/') then
    Result := BaseUrl + 'catalog/infobyids'
  else
    Result := BaseUrl + '/catalog/infobyids';
end;

class function TGetItRestService.BuildRestBody(const Request: TGetItRestRequest;
  const BuildNumber: string; const StartIndex, EndIndex: Integer): string;
begin
  Result := Format(
    'Start=%d&End=%d&Categories=-1&CalculateSize=0&FilterByLicense=0&Order=0' +
    '&Version=%s&Identity=RADSTUDIO&Personalities=1%%3B2%%3B3%%3B4%%3B5%%3B6%%3B7' +
    '&Platforms=0&Frameworks=0&Language=0&ProductSKU=%s&IsTrial=0&CatalogVersion=%s' +
    '&ClientVersion=7.0&LanguageCode=EN&ProductId=%s&ProductIds=%s&ProductSKUs=%s&IsTrials=0&Search=%s',
    [StartIndex, EndIndex, TNetEncoding.URL.Encode(Request.IDEVersion),
     TNetEncoding.URL.Encode(Request.ProductSku), TNetEncoding.URL.Encode(Request.CatalogVersion),
     TNetEncoding.URL.Encode(Request.ProductId), TNetEncoding.URL.Encode(Request.ProductId),
     TNetEncoding.URL.Encode(Request.ProductSku), TNetEncoding.URL.Encode(Request.SearchText)]);
  if BuildNumber <> '' then
    Result := Result + '&BuildNumber=' + TNetEncoding.URL.Encode(BuildNumber);
end;

class function TGetItRestService.BuildInfoByIdsBody(const Request: TGetItRestRequest; const IdList: string): string;
begin
  Result := Format('CatalogVersion=%s&Id=%s',
    [TNetEncoding.URL.Encode(Request.CatalogVersion),
     TNetEncoding.URL.Encode(IdList)]);
end;

class function TGetItRestService.JsonValueToString(const Obj: TJSONObject; const Name: string): string;
begin
  Result := '';
  Obj.TryGetValue<string>(Name, Result);
end;


class function TGetItRestService.ReadTargets(const Obj: TJSONObject;
  const Field: string): TArray<TGetItNamedId>;
var
  Value: TJSONValue;
  Item: TJSONObject;
begin
  Result := nil;
  Value := Obj.GetValue(Field);
  if (Value = nil) or (Value is TJSONNull) then
    Exit;
  if not (Value is TJSONArray) then
    raise EGetItCatalogError.Create(Field + ' must be an array.');
  SetLength(Result, TJSONArray(Value).Count);
  for var i := 0 to High(Result) do
  begin
    if not (TJSONArray(Value).Items[i] is TJSONObject) then
      raise EGetItCatalogError.Create(Field + ' contains a non-object entry.');
    Item := TJSONObject(TJSONArray(Value).Items[i]);
    Result[i].Id := JsonValueToString(Item, 'Id');
    Result[i].Name := JsonValueToString(Item, 'Name');
    if Result[i].Id = '' then
      raise EGetItCatalogError.Create(Field + ' contains an entry without an ID.');
  end;
end;

class function TGetItRestService.ReadPackage(const Obj: TJSONObject): TGetItPackageInfo;
var
  Platforms, OSes: TArray<TGetItNamedId>;
begin
  Platforms := ReadTargets(Obj, 'LibPlatforms');
  OSes := ReadTargets(Obj, 'LibOSes');
  Result := TGetItPackageInfo.Create;
  Result.Platforms := Platforms;
  Result.OSes := OSes;
  Result.Id := JsonValueToString(Obj, 'Id');
  Result.PackageId := JsonValueToString(Obj, 'PackageId');
  Result.Version := JsonValueToString(Obj, 'Version');
  Result.Name := JsonValueToString(Obj, 'Name');
  Result.Vendor := JsonValueToString(Obj, 'Vendor');
  Result.Description := JsonValueToString(Obj, 'Description');
  Result.Tags := JsonValueToString(Obj, 'Tags');
  Result.TypeDescription := JsonValueToString(Obj, 'TypeDescription');
  Result.State := JsonValueToString(Obj, 'State');
  Result.Subscription := JsonValueToString(Obj, 'Subscription');
  ReadCategories(Obj, Result.CategoryIds, Result.CategoryNames);
  Result.LibCode := JsonValueToString(Obj, 'LibCode');
  Result.LibCodeName := JsonValueToString(Obj, 'LibCodeName');
  Result.LibSize := JsonValueToString(Obj, 'LibSize');
  Result.LibUrl := JsonValueToString(Obj, 'LibUrl');
  Result.LibMD5 := JsonValueToString(Obj, 'LibMD5');
  Result.VendorUrl := JsonValueToString(Obj, 'VendorUrl');
  Result.VersionTimestamp := JsonValueToString(Obj, 'VersionTimestamp');
  Result.Modified := JsonValueToString(Obj, 'Modified');
  Result.CatalogDetailsJson := Obj.ToJSON;
  Result.ImageUrl := JsonValueToString(Obj, 'Image');
  Result.IconUrl := JsonValueToString(Obj, 'Icon');
  Result.LicenseUrl := JsonValueToString(Obj, 'LibLicense');
  Result.LicenseName := JsonValueToString(Obj, 'LibLicenseName');
  Result.ProjectUrl := JsonValueToString(Obj, 'LibProjectUrl');

  if Result.Name.IsEmpty then
    Result.Name := TGetItCore.ExtractNameFromId(Result.Id);
end;

class procedure TGetItRestService.AddJsonPackages(const Arr: TJSONArray;
  const Target: TObjectDictionary<string, TGetItPackageInfo>; const CatalogUnavailable: Boolean);
begin
  for var i := 0 to Arr.Count - 1 do
  begin
    if not (Arr.Items[i] is TJSONObject) then
      Continue;

    var Obj := Arr.Items[i] as TJSONObject;
    var Pkg := ReadPackage(Obj);
    Pkg.CatalogUnavailable := CatalogUnavailable;

    if Pkg.Id <> '' then
      Target.AddOrSetValue(Pkg.Id, Pkg)
    else
      Pkg.Free;
  end;
end;

class procedure TGetItRestService.ReadCategories(const Obj: TJSONObject; out CategoryIds, CategoryNames: string);
var
  CategoriesValue: TJSONValue;
  CategoriesArray: TJSONArray;
  CategoryObj: TJSONObject;
  CategoryId: string;
  CategoryName: string;
begin
  CategoryIds := '';
  CategoryNames := '';

  CategoriesValue := Obj.GetValue('Categories');
  if not (CategoriesValue is TJSONArray) then
    Exit;

  CategoriesArray := TJSONArray(CategoriesValue);
  for var i := 0 to CategoriesArray.Count - 1 do
  begin
    if not (CategoriesArray.Items[i] is TJSONObject) then
      Continue;

    CategoryObj := CategoriesArray.Items[i] as TJSONObject;
    CategoryId := JsonValueToString(CategoryObj, 'Id');
    CategoryName := JsonValueToString(CategoryObj, 'Name');

    if CategoryId <> '' then
    begin
      if CategoryIds <> '' then
        CategoryIds := CategoryIds + ', ';
      CategoryIds := CategoryIds + CategoryId;
    end;

    if CategoryName <> '' then
    begin
      if CategoryNames <> '' then
        CategoryNames := CategoryNames + ', ';
      CategoryNames := CategoryNames + CategoryName;
    end;
  end;
end;

class function TGetItRestService.ResponsePreview(const Content: string; const MaxLen: Integer): string;
var
  Normalized: string;
begin
  Normalized := Content.Replace(#13, ' ').Replace(#10, ' ').Trim;
  if Length(Normalized) > MaxLen then
    Result := Copy(Normalized, 1, MaxLen) + '...'
  else
    Result := Normalized;
end;

class function TGetItRestService.TryGetArrayFromPayload(const JsonRoot: TJSONValue; out Arr: TJSONArray): Boolean;
const
  TopLevelArrayKeys: array[0..11] of string = (
    'Items', 'items', 'Data', 'data', 'Result', 'result',
    'Value', 'value', 'CatalogItems', 'catalogItems', 'Packages', 'packages');
  NestedObjectKeys: array[0..5] of string = ('Data', 'data', 'Result', 'result', 'Value', 'value');
  NestedArrayKeys: array[0..3] of string = ('Items', 'items', 'Packages', 'packages');
var
  Obj: TJSONObject;
  NestedObj: TJSONObject;
  V: TJSONValue;
begin
  Arr := nil;

  if JsonRoot is TJSONArray then
  begin
    Arr := TJSONArray(JsonRoot);
    Exit(True);
  end;

  if not (JsonRoot is TJSONObject) then
    Exit(False);

  Obj := TJSONObject(JsonRoot);

  for var Key in TopLevelArrayKeys do
  begin
    V := Obj.GetValue(Key);
    if V is TJSONArray then
    begin
      Arr := TJSONArray(V);
      Exit(True);
    end;
  end;

  for var ContainerKey in NestedObjectKeys do
  begin
    V := Obj.GetValue(ContainerKey);
    if not (V is TJSONObject) then
      Continue;

    NestedObj := TJSONObject(V);
    for var ArrayKey in NestedArrayKeys do
    begin
      V := NestedObj.GetValue(ArrayKey);
      if V is TJSONArray then
      begin
        Arr := TJSONArray(V);
        Exit(True);
      end;
    end;
  end;

  Result := False;
end;

class procedure TGetItRestService.FetchPackages(const Request: TGetItRestRequest;
  const Target: TObjectDictionary<string, TGetItPackageInfo>; const OnLog: TGetItRestLogProc);
var
  Compatible: TObjectDictionary<string, TGetItPackageInfo>;
begin
  if Request.BuildNumber = '' then
    raise EArgumentException.Create('REST catalog requires the selected IDE executable build number.');
  if Request.InstalledPersonalities = [] then
    raise EArgumentException.Create('REST catalog requires the installed IDE personalities.');
  Compatible := TObjectDictionary<string, TGetItPackageInfo>.Create([doOwnsValues]);
  try
    OnLog('REST full catalog: all builds and application targets.');
    FetchCatalog(Request, '', Target, OnLog);
    OnLog('REST compatible catalog: build ' + Request.BuildNumber);
    FetchCatalog(Request, Request.BuildNumber, Compatible, OnLog);
    for var Pkg in Target.Values do
    begin
      Pkg.IncompatibilityReasons := [];
      if not Compatible.ContainsKey(Pkg.Id) then
        Include(Pkg.IncompatibilityReasons, irBuild);
      if not TGetItCore.SupportsPackagePersonality(Pkg.LibCode, Request.InstalledPersonalities) then
        Include(Pkg.IncompatibilityReasons, irPersonality);
    end;
  finally
    Compatible.Free;
  end;
end;

class procedure TGetItRestService.FetchCatalog(const Request: TGetItRestRequest; const BuildNumber: string;
  const Target: TObjectDictionary<string, TGetItPackageInfo>; const OnLog: TGetItRestLogProc);
var
  HttpClient: THTTPClient;
  ReqStream: TStringStream;
  ReqHeaders: TNetHeaders;
  Resp: IHTTPResponse;
  RestUrl: string;
  Body: string;
  ContentText: string;
  JsonRoot: TJSONValue;
  Arr: TJSONArray;
  PageStart: Integer;
  PageSize: Integer;
  ItemsInPage: Integer;
begin
  RestUrl := CatalogInfoUrl(Request.ServiceUrl);
  ReqHeaders := [TNameValuePair.Create('Content-Type', 'application/x-www-form-urlencoded')];

  PageStart := 0;
  PageSize := 300;
  HttpClient := THTTPClient.Create;
  try
    repeat
      Body := BuildRestBody(Request, BuildNumber, PageStart, PageStart + PageSize);
      OnLog(Format('REST body page: Start=%d End=%d', [PageStart, PageStart + PageSize]));

      ReqStream := TStringStream.Create(Body, TEncoding.UTF8);
      try
        Resp := HttpClient.Post(RestUrl, ReqStream, nil, ReqHeaders);
      finally
        ReqStream.Free;
      end;

      if Resp.StatusCode <> 200 then
        raise EGetItCatalogError.CreateFmt('REST call failed with status %d', [Resp.StatusCode]);

      ContentText := Resp.ContentAsString(TEncoding.UTF8);
      JsonRoot := TJSONObject.ParseJSONValue(ContentText);
      try
        if JsonRoot = nil then
          raise EGetItCatalogError.Create('Invalid JSON payload. Preview: ' + ResponsePreview(ContentText));

        if not TryGetArrayFromPayload(JsonRoot, Arr) then
          raise EGetItCatalogError.CreateFmt('Unexpected REST payload (%s). Preview: %s',
            [JsonRoot.ClassName, ResponsePreview(ContentText)]);

        ItemsInPage := Arr.Count;

        AddJsonPackages(Arr, Target, False);
      finally
        JsonRoot.Free;
      end;

      Inc(PageStart, PageSize);
    until ItemsInPage < PageSize;
  finally
    HttpClient.Free;
  end;
end;

class procedure TGetItRestService.FetchPackagesByIds(const Request: TGetItRestRequest; const Ids: TStrings;
  const Target: TObjectDictionary<string, TGetItPackageInfo>; const OnLog: TGetItRestLogProc);
const
  IDS_PER_REQUEST = 40;
var
  HttpClient: THTTPClient;
  ReqStream: TStringStream;
  ReqHeaders: TNetHeaders;
  Resp: IHTTPResponse;
  RestUrl: string;
  Body: string;
  ContentText: string;
  JsonRoot: TJSONValue;
  Arr: TJSONArray;
  StartIndex: Integer;
  EndIndex: Integer;
  IdList: string;
begin
  if (Ids = nil) or (Ids.Count = 0) then
    Exit;

  RestUrl := CatalogInfoByIdsUrl(Request.ServiceUrl);
  ReqHeaders := [TNameValuePair.Create('Content-Type', 'application/x-www-form-urlencoded')];
  HttpClient := THTTPClient.Create;
  try
    HttpClient.ConnectionTimeout := 5000;
    HttpClient.ResponseTimeout := 15000;
    StartIndex := 0;
    while StartIndex < Ids.Count do
    begin
      EndIndex := StartIndex + IDS_PER_REQUEST - 1;
      if EndIndex >= Ids.Count then
        EndIndex := Ids.Count - 1;

      IdList := '';
      for var i := StartIndex to EndIndex do
      begin
        if IdList <> '' then
          IdList := IdList + ';';
        IdList := IdList + Ids[i];
      end;

      if Assigned(OnLog) then
        OnLog(Format('REST infobyids: %d installed ids (%d..%d).',
          [EndIndex - StartIndex + 1, StartIndex + 1, EndIndex + 1]));

      Body := BuildInfoByIdsBody(Request, IdList);
      ReqStream := TStringStream.Create(Body, TEncoding.UTF8);
      try
        Resp := HttpClient.Post(RestUrl, ReqStream, nil, ReqHeaders);
      finally
        ReqStream.Free;
      end;

      if Resp.StatusCode <> 200 then
        raise EGetItCatalogError.CreateFmt('REST infobyids failed with status %d', [Resp.StatusCode]);

      ContentText := Resp.ContentAsString(TEncoding.UTF8);
      JsonRoot := TJSONObject.ParseJSONValue(ContentText);
      try
        if JsonRoot = nil then
          raise EGetItCatalogError.Create('Invalid infobyids JSON payload. Preview: ' + ResponsePreview(ContentText));

        if not TryGetArrayFromPayload(JsonRoot, Arr) then
          raise EGetItCatalogError.CreateFmt('Unexpected infobyids payload (%s). Preview: %s',
            [JsonRoot.ClassName, ResponsePreview(ContentText)]);

        AddJsonPackages(Arr, Target, True);
      finally
        JsonRoot.Free;
      end;

      Inc(StartIndex, IDS_PER_REQUEST);
    end;
  finally
    HttpClient.Free;
  end;
end;

end.