petstore.client.pas

// Client unit for Swagger Petstore
// - This is a sample server Petstore server.  You can find out more about Swagger
// at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/).
//  For this sample, you can use the api key `special-key` to test the authorization
// filters.
// - version 1.0.7
// - OpenAPI definition licensed under Apache 2.0 terms
unit petstore.client;

{$I mormot.defines.inc}

interface

{
  --------------------------------------------------------------------
  SWAGGER PETSTORE client as TPetStoreClient class

  Generated 6 Sep 2024 by ab via mormot2tests - DO NOT MODIFY BY HAND!
  --------------------------------------------------------------------
}

uses
  classes,
  sysutils,
  mormot.core.base,
  mormot.core.unicode,
  mormot.core.text,
  mormot.core.buffers,
  mormot.core.datetime,
  mormot.core.rtti,
  mormot.core.json,
  mormot.core.variants,
  mormot.net.client,
  petstore.dto;

type

{ ************ Main TPetStoreClient Class }

  // Client class for Swagger Petstore
  // - This is a sample server Petstore server.  You can find out more about Swagger
  // at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/).
  //  For this sample, you can use the api key `special-key` to test the authorization
  // filters.
  TPetStoreClient = class
  private
    fClient: IJsonClient;
  public

    // initialize this Client with an associated HTTP/JSON request
    constructor Create(const aClient: IJsonClient = nil);


    // -------------
    //  PET METHODS
    // -------------
    // - Everything about your Pets


    // uploadFile [post] /pet/{petId}/uploadImage
    //
    // Summary: uploads an image
    //
    // Params:
    // - [path] PetId (required): ID of pet to update
    // - [formData] AdditionalMetadata (unsupported): Additional data to pass to server
    // - [formData] _File (unsupported): file to upload
    //
    // Responses:
    // - 200 (main): successful operation
    function UploadFile(PetId: Int64): TApiResponse;

    // addPet [post] /pet
    //
    // Summary: Add a new pet to the store
    //
    // Params:
    // - [body] Payload  (required)
    //
    // Responses:
    // - 405: Invalid input
    procedure AddPet(const Payload: TPet);

    // updatePet [put] /pet
    //
    // Summary: Update an existing pet
    //
    // Params:
    // - [body] Payload  (required)
    //
    // Responses:
    // - 400: Invalid ID supplied
    // - 404: Pet not found
    // - 405: Validation exception
    procedure UpdatePet(const Payload: TPet);

    // findPetsByStatus [get] /pet/findByStatus
    //
    // Summary: Finds Pets by status
    // Description:
    //   Multiple status values can be provided with comma separated strings
    //
    // Params:
    // - [query] Status (required): Status values that need to be considered for filter
    //
    // Responses:
    // - 200 (main): successful operation
    // - 400: Invalid status value
    function FindPetsByStatus(Status: TEnumPetStore1Set): TPetDynArray;

    // [DEPRECATED] findPetsByTags [get] /pet/findByTags
    //
    // Summary: Finds Pets by tags
    // Description:
    //   Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing.
    //
    // Params:
    // - [query] Tags (required): Tags to filter by
    //
    // Responses:
    // - 200 (main): successful operation
    // - 400: Invalid tag value
    function FindPetsByTags_deprecated(const Tags: TRawUtf8DynArray): TPetDynArray;

    // getPetById [get] /pet/{petId}
    //
    // Summary: Find pet by ID
    // Description:
    //   Returns a single pet
    //
    // Params:
    // - [path] PetId (required): ID of pet to return
    //
    // Responses:
    // - 200 (main): successful operation
    // - 400: Invalid ID supplied
    // - 404: Pet not found
    function GetPetById(PetId: Int64): TPet;

    // updatePetWithForm [post] /pet/{petId}
    //
    // Summary: Updates a pet in the store with form data
    //
    // Params:
    // - [path] PetId (required): ID of pet that needs to be updated
    // - [formData] Name (unsupported): Updated name of the pet
    // - [formData] Status (unsupported): Updated status of the pet
    //
    // Responses:
    // - 405: Invalid input
    procedure UpdatePetWithForm(PetId: Int64);

    // deletePet [delete] /pet/{petId}
    //
    // Summary: Deletes a pet
    //
    // Params:
    // - [header] ApiKey
    // - [path] PetId (required): Pet id to delete
    //
    // Responses:
    // - 400: Invalid ID supplied
    // - 404: Pet not found
    procedure DeletePet(PetId: Int64; const ApiKey: RawUtf8 = '');


    // ---------------
    //  STORE METHODS
    // ---------------
    // - Access to Petstore orders


    // getInventory [get] /store/inventory
    //
    // Summary: Returns pet inventories by status
    // Description:
    //   Returns a map of status codes to quantities
    //
    // Responses:
    // - 200 (main): successful operation
    function GetInventory(): variant;

    // placeOrder [post] /store/order
    //
    // Summary: Place an order for a pet
    //
    // Params:
    // - [body] Payload  (required)
    //
    // Responses:
    // - 200 (main): successful operation
    // - 400: Invalid Order
    function PlaceOrder(const Payload: TOrder): TOrder;

    // getOrderById [get] /store/order/{orderId}
    //
    // Summary: Find purchase order by ID
    // Description:
    //   For valid response try integer IDs with value >= 1 and <= 10. Other values will generated exceptions
    //
    // Params:
    // - [path] OrderId (required): ID of pet that needs to be fetched
    //
    // Responses:
    // - 200 (main): successful operation
    // - 400: Invalid ID supplied
    // - 404: Order not found
    function GetOrderById(OrderId: Int64): TOrder;

    // deleteOrder [delete] /store/order/{orderId}
    //
    // Summary: Delete purchase order by ID
    // Description:
    //   For valid response try integer IDs with positive integer value. Negative or non-integer values will generate API errors
    //
    // Params:
    // - [path] OrderId (required): ID of the order that needs to be deleted
    //
    // Responses:
    // - 400: Invalid ID supplied
    // - 404: Order not found
    procedure DeleteOrder(OrderId: Int64);


    // --------------
    //  USER METHODS
    // --------------
    // - Operations about user


    // createUsersWithListInput [post] /user/createWithList
    //
    // Summary: Creates list of users with given input array
    //
    // Params:
    // - [body] Payload  (required)
    //
    // Responses:
    // - default (main): successful operation
    procedure CreateUsersWithListInput(const Payload: TUserDynArray);

    // getUserByName [get] /user/{username}
    //
    // Summary: Get user by user name
    //
    // Params:
    // - [path] Username (required): The name that needs to be fetched. Use user1
    // for testing.
    //
    // Responses:
    // - 200 (main): successful operation
    // - 400: Invalid username supplied
    // - 404: User not found
    function GetUserByName(const Username: RawUtf8): TUser;

    // updateUser [put] /user/{username}
    //
    // Summary: Updated user
    // Description:
    //   This can only be done by the logged in user.
    //
    // Params:
    // - [path] Username (required): name that need to be updated
    // - [body] Payload  (required)
    //
    // Responses:
    // - 400: Invalid user supplied
    // - 404: User not found
    procedure UpdateUser(const Username: RawUtf8; const Payload: TUser);

    // deleteUser [delete] /user/{username}
    //
    // Summary: Delete user
    // Description:
    //   This can only be done by the logged in user.
    //
    // Params:
    // - [path] Username (required): The name that needs to be deleted
    //
    // Responses:
    // - 400: Invalid username supplied
    // - 404: User not found
    procedure DeleteUser(const Username: RawUtf8);

    // loginUser [get] /user/login
    //
    // Summary: Logs user into the system
    //
    // Params:
    // - [query] Username (required): The user name for login
    // - [query] Password (required): The password for login in clear text
    //
    // Responses:
    // - 200 (main): successful operation
    // - 400: Invalid username/password supplied
    function LoginUser(const Username: RawUtf8; const Password: RawUtf8): RawUtf8;

    // logoutUser [get] /user/logout
    //
    // Summary: Logs out current logged in user session
    //
    // Responses:
    // - default (main): successful operation
    procedure LogoutUser();

    // createUsersWithArrayInput [post] /user/createWithArray
    //
    // Summary: Creates list of users with given input array
    //
    // Params:
    // - [body] Payload  (required)
    //
    // Responses:
    // - default (main): successful operation
    procedure CreateUsersWithArrayInput(const Payload: TUserDynArray);

    // createUser [post] /user
    //
    // Summary: Create user
    // Description:
    //   This can only be done by the logged in user.
    //
    // Params:
    // - [body] Payload  (required)
    //
    // Responses:
    // - default (main): successful operation
    procedure CreateUser(const Payload: TUser);

    // access to the associated HTTP/JSON request
    property JsonClient: IJsonClient
      read fClient write fClient;
  end;


implementation



{ ************ Main TPetStoreClient Class }

{ TPetStoreClient}

constructor TPetStoreClient.Create(const aClient: IJsonClient);
begin
  fClient := aClient;
  fClient.UrlEncoder :=
    [ueEncodeNames, ueSkipVoidString, ueSkipVoidValue, ueStarNameIsCsv];
end;

function TPetStoreClient.UploadFile(PetId: Int64): TApiResponse;
begin
  fClient.Request('POST', '/v2/pet/%/uploadImage', [PetId], [], [],
    result, TypeInfo(TApiResponse));
end;

procedure TPetStoreClient.AddPet(const Payload: TPet);
begin
  fClient.Request('POST', '/v2/pet', [], [], [],
    Payload, {dummy:}self, TypeInfo(TPet), nil);
end;

procedure TPetStoreClient.UpdatePet(const Payload: TPet);
begin
  fClient.Request('PUT', '/v2/pet', [], [], [],
    Payload, {dummy:}self, TypeInfo(TPet), nil);
end;

function TPetStoreClient.FindPetsByStatus(Status: TEnumPetStore1Set): TPetDynArray;
begin
  fClient.Request('GET', '/v2/pet/findByStatus', [], [
    '*status', GetSetNameCustom(TypeInfo(TEnumPetStore1), Status, @ENUMPETSTORE1_TXT)], [],
    result, TypeInfo(TPetDynArray));
end;

function TPetStoreClient.FindPetsByTags_deprecated(const Tags: TRawUtf8DynArray): TPetDynArray;
begin
  fClient.Request('GET', '/v2/pet/findByTags', [], [
    '*tags', RawUtf8ArrayToCsv(Tags)], [],
    result, TypeInfo(TPetDynArray));
end;

function TPetStoreClient.GetPetById(PetId: Int64): TPet;
begin
  fClient.Request('GET', '/v2/pet/%', [PetId], [], [],
    result, TypeInfo(TPet));
end;

procedure TPetStoreClient.UpdatePetWithForm(PetId: Int64);
begin
  fClient.Request('POST', '/v2/pet/%', [PetId], [], []);
end;

procedure TPetStoreClient.DeletePet(PetId: Int64; const ApiKey: RawUtf8);
begin
  fClient.Request('DELETE', '/v2/pet/%', [PetId], [], [
    'api_key', ApiKey]);
end;

function TPetStoreClient.GetInventory(): variant;
begin
  fClient.Request('GET', '/v2/store/inventory', [], [], [],
    result, TypeInfo(variant));
end;

function TPetStoreClient.PlaceOrder(const Payload: TOrder): TOrder;
begin
  fClient.Request('POST', '/v2/store/order', [], [], [],
    Payload, result, TypeInfo(TOrder), TypeInfo(TOrder));
end;

function TPetStoreClient.GetOrderById(OrderId: Int64): TOrder;
begin
  fClient.Request('GET', '/v2/store/order/%', [OrderId], [], [],
    result, TypeInfo(TOrder));
end;

procedure TPetStoreClient.DeleteOrder(OrderId: Int64);
begin
  fClient.Request('DELETE', '/v2/store/order/%', [OrderId], [], []);
end;

procedure TPetStoreClient.CreateUsersWithListInput(const Payload: TUserDynArray);
begin
  fClient.Request('POST', '/v2/user/createWithList', [], [], [],
    Payload, {dummy:}self, TypeInfo(TUserDynArray), nil);
end;

function TPetStoreClient.GetUserByName(const Username: RawUtf8): TUser;
begin
  fClient.Request('GET', '/v2/user/%', [Username], [], [],
    result, TypeInfo(TUser));
end;

procedure TPetStoreClient.UpdateUser(const Username: RawUtf8; const Payload: TUser);
begin
  fClient.Request('PUT', '/v2/user/%', [Username], [], [],
    Payload, {dummy:}self, TypeInfo(TUser), nil);
end;

procedure TPetStoreClient.DeleteUser(const Username: RawUtf8);
begin
  fClient.Request('DELETE', '/v2/user/%', [Username], [], []);
end;

function TPetStoreClient.LoginUser(const Username: RawUtf8; const Password: RawUtf8): RawUtf8;
begin
  fClient.Request('GET', '/v2/user/login', [], [
    'username', Username,
    'password', Password], [],
    result, TypeInfo(RawUtf8));
end;

procedure TPetStoreClient.LogoutUser();
begin
  fClient.Request('GET', '/v2/user/logout', [], [], []);
end;

procedure TPetStoreClient.CreateUsersWithArrayInput(const Payload: TUserDynArray);
begin
  fClient.Request('POST', '/v2/user/createWithArray', [], [], [],
    Payload, {dummy:}self, TypeInfo(TUserDynArray), nil);
end;

procedure TPetStoreClient.CreateUser(const Payload: TUser);
begin
  fClient.Request('POST', '/v2/user', [], [], [],
    Payload, {dummy:}self, TypeInfo(TUser), nil);
end;


end.

petstore.dto.pas

// DTOs for Swagger Petstore
// - This is a sample server Petstore server.  You can find out more about Swagger
// at [http://swagger.io](http://swagger.io) or on [irc.freenode.net, #swagger](http://swagger.io/irc/).
//  For this sample, you can use the api key `special-key` to test the authorization
// filters.
// - version 1.0.7
// - OpenAPI definition licensed under Apache 2.0 terms
unit petstore.dto;

{$I mormot.defines.inc}

interface

{
  --------------------------------------------------------------------
  SWAGGER PETSTORE DTOs

  Generated 6 Sep 2024 by ab via mormot2tests - DO NOT MODIFY BY HAND!
  --------------------------------------------------------------------
}

uses
  classes,
  sysutils,
  mormot.core.base,
  mormot.core.rtti,
  mormot.core.json;

type

{ ************ Enumerations and Sets }

  // pet status in the store
  TEnumPetStore1 = (
    ep1None, ep1Available, ep1Pending, ep1Sold);
  TEnumPetStore1Set = set of TEnumPetStore1;
  // Order Status
  TEnumPetStore2 = (
    ep2None, ep2Approved, ep2Delivered, ep2Placed);


{ ************ Data Transfert Objects }

  // from #/definitions/ApiResponse
  TApiResponse = packed record
    Code: integer;
    _Type: RawUtf8;
    Message: RawUtf8;
  end;
  PApiResponse = ^TApiResponse;

  // from #/definitions/Category
  TCategory = packed record
    Id: Int64;
    Name: RawUtf8;
  end;
  PCategory = ^TCategory;

  // from #/definitions/Tag
  TTag = packed record
    Id: Int64;
    Name: RawUtf8;
  end;
  PTag = ^TTag;
  TTagDynArray = array of TTag;

  // from #/definitions/Pet
  TPet = packed record
    Id: Int64;
    Category: TCategory;
    Name: RawUtf8;
    PhotoUrls: TRawUtf8DynArray;
    Tags: TTagDynArray;
    // pet status in the store
    Status: TEnumPetStore1;
  end;
  PPet = ^TPet;
  TPetDynArray = array of TPet;

  // from #/definitions/Order
  TOrder = packed record
    Id: Int64;
    PetId: Int64;
    Quantity: integer;
    ShipDate: TDateTime;
    // Order Status
    Status: TEnumPetStore2;
    Complete: boolean;
  end;
  POrder = ^TOrder;

  // from #/definitions/User
  TUser = packed record
    Id: Int64;
    Username: RawUtf8;
    FirstName: RawUtf8;
    LastName: RawUtf8;
    Email: RawUtf8;
    Password: RawUtf8;
    Phone: RawUtf8;
    // User Status
    UserStatus: integer;
  end;
  PUser = ^TUser;
  TUserDynArray = array of TUser;



const
  // define how enums/sets are actually transmitted as JSON array of string
  ENUMPETSTORE1_TXT: array[TEnumPetStore1] of RawUtf8 = (
    '', 'available', 'pending', 'sold');
  ENUMPETSTORE2_TXT: array[TEnumPetStore2] of RawUtf8 = (
    '', 'approved', 'delivered', 'placed');


implementation

{ ************ Custom RTTI/JSON initialization }

const
  // exact definition of the DTOs expected JSON serialization
  _TApiResponse = 'code:integer type:RawUtf8 message:RawUtf8';
  _TCategory = 'id:Int64 name:RawUtf8';
  _TTag = 'id:Int64 name:RawUtf8';
  _TPet = 'id:Int64 category:TCategory name:RawUtf8 photoUrls:TRawUtf8DynArray ' +
    'tags:array of TTag status:TEnumPetStore1';
  _TOrder = 'id:Int64 petId:Int64 quantity:integer shipDate:TDateTime status:TEnumPetStore2 ' +
    'complete:boolean';
  _TUser = 'id:Int64 username:RawUtf8 firstName:RawUtf8 lastName:RawUtf8 ' +
    'email:RawUtf8 password:RawUtf8 phone:RawUtf8 userStatus:integer';


procedure RegisterRtti;
begin
  TRttiJson.RegisterCustomEnumValues([
    TypeInfo(TEnumPetStore1), TypeInfo(TEnumPetStore1Set), @ENUMPETSTORE1_TXT,
    TypeInfo(TEnumPetStore2), nil, @ENUMPETSTORE2_TXT]);
  Rtti.RegisterFromText([
    TypeInfo(TApiResponse), _TApiResponse,
    TypeInfo(TCategory), _TCategory,
    TypeInfo(TTag), _TTag,
    TypeInfo(TPet), _TPet,
    TypeInfo(TOrder), _TOrder,
    TypeInfo(TUser), _TUser]);
end;

initialization
  RegisterRtti;

end.