OpenAPI definition

GameRestController

deleteGame

Delete a game


/api/games/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | id of the game

        try {
            Game result = apiInstance.deleteGame(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#deleteGame");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | id of the game

        try {
            Game result = apiInstance.deleteGame(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#deleteGame");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Long *id = 789; // id of the game (default to null)

// Delete a game
[apiInstance deleteGameWith:id
              completionHandler: ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var id = 789; // {Long} id of the game

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteGame(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteGameExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var id = 789;  // Long | id of the game (default to null)

            try {
                // Delete a game
                Game result = apiInstance.deleteGame(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.deleteGame: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$id = 789; // Long | id of the game

try {
    $result = $api_instance->deleteGame($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->deleteGame: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $id = 789; # Long | id of the game

eval {
    my $result = $api_instance->deleteGame(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->deleteGame: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
id = 789 # Long | id of the game (default to null)

try:
    # Delete a game
    api_response = api_instance.delete_game(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->deleteGame: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = GameRestControllerApi::Context::default();
    let result = client.deleteGame(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the game

Required

Responses

Status: 404 - Game not found

Status: 200 - Game deleted

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

downloadGameplayImages

Get the gameplay images of a game


/api/games/{id}/gameplayImage/{index}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/{id}/gameplayImage/{index}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | id of the game
        Integer index = 56; // Integer | index of the gameplay image

        try {
            Game result = apiInstance.downloadGameplayImages(id, index);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#downloadGameplayImages");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | id of the game
        Integer index = 56; // Integer | index of the gameplay image

        try {
            Game result = apiInstance.downloadGameplayImages(id, index);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#downloadGameplayImages");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Long *id = 789; // id of the game (default to null)
Integer *index = 56; // index of the gameplay image (default to null)

// Get the gameplay images of a game
[apiInstance downloadGameplayImagesWith:id
    index:index
              completionHandler: ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var id = 789; // {Long} id of the game
var index = 56; // {Integer} index of the gameplay image

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.downloadGameplayImages(id, index, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class downloadGameplayImagesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var id = 789;  // Long | id of the game (default to null)
            var index = 56;  // Integer | index of the gameplay image (default to null)

            try {
                // Get the gameplay images of a game
                Game result = apiInstance.downloadGameplayImages(id, index);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.downloadGameplayImages: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$id = 789; // Long | id of the game
$index = 56; // Integer | index of the gameplay image

try {
    $result = $api_instance->downloadGameplayImages($id, $index);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->downloadGameplayImages: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $id = 789; # Long | id of the game
my $index = 56; # Integer | index of the gameplay image

eval {
    my $result = $api_instance->downloadGameplayImages(id => $id, index => $index);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->downloadGameplayImages: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
id = 789 # Long | id of the game (default to null)
index = 56 # Integer | index of the gameplay image (default to null)

try:
    # Get the gameplay images of a game
    api_response = api_instance.download_gameplay_images(id, index)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->downloadGameplayImages: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let index = 56; // Integer

    let mut context = GameRestControllerApi::Context::default();
    let result = client.downloadGameplayImages(id, index, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the game

Required
index*
Integer (int32)

index of the gameplay image

Required

Responses

Status: 404 - Gameplay images not found

Status: 200 - Found the gameplay images

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

downloadImageProfile1

Get the cover image of a game


/api/games/{id}/coverImage

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/{id}/coverImage"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | id of the game

        try {
            Game result = apiInstance.downloadImageProfile1(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#downloadImageProfile1");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | id of the game

        try {
            Game result = apiInstance.downloadImageProfile1(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#downloadImageProfile1");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Long *id = 789; // id of the game (default to null)

// Get the cover image of a game
[apiInstance downloadImageProfile1With:id
              completionHandler: ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var id = 789; // {Long} id of the game

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.downloadImageProfile1(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class downloadImageProfile1Example
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var id = 789;  // Long | id of the game (default to null)

            try {
                // Get the cover image of a game
                Game result = apiInstance.downloadImageProfile1(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.downloadImageProfile1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$id = 789; // Long | id of the game

try {
    $result = $api_instance->downloadImageProfile1($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->downloadImageProfile1: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $id = 789; # Long | id of the game

eval {
    my $result = $api_instance->downloadImageProfile1(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->downloadImageProfile1: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
id = 789 # Long | id of the game (default to null)

try:
    # Get the cover image of a game
    api_response = api_instance.download_image_profile1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->downloadImageProfile1: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = GameRestControllerApi::Context::default();
    let result = client.downloadImageProfile1(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the game

Required

Responses

Status: 404 - Cover not found

Status: 200 - Found the cover image

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

editGame

Edit a game


/api/games/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/{id}?game=&imageField=BINARY_DATA_HERE&imageFields="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Game game = ; // Game | 
        File imageField = BINARY_DATA_HERE; // File | 
        array[File] imageFields = ; // array[File] | 
        Long id = 789; // Long | id of the game

        try {
            Game result = apiInstance.editGame(game, imageField, imageFields, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#editGame");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Game game = ; // Game | 
        File imageField = BINARY_DATA_HERE; // File | 
        array[File] imageFields = ; // array[File] | 
        Long id = 789; // Long | id of the game

        try {
            Game result = apiInstance.editGame(game, imageField, imageFields, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#editGame");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Game *game = ; //  (default to null)
File *imageField = BINARY_DATA_HERE; //  (default to null)
array[File] *imageFields = ; //  (default to null)
Long *id = 789; // id of the game (default to null)

// Edit a game
[apiInstance editGameWith:game
    imageField:imageField
    imageFields:imageFields
    id:id
              completionHandler: ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var game = ; // {Game} 
var imageField = BINARY_DATA_HERE; // {File} 
var imageFields = ; // {array[File]} 
var id = 789; // {Long} id of the game

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.editGame(game, imageField, imageFields, id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class editGameExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var game = new Game(); // Game |  (default to null)
            var imageField = BINARY_DATA_HERE;  // File |  (default to null)
            var imageFields = new array[File](); // array[File] |  (default to null)
            var id = 789;  // Long | id of the game (default to null)

            try {
                // Edit a game
                Game result = apiInstance.editGame(game, imageField, imageFields, id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.editGame: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$game = ; // Game | 
$imageField = BINARY_DATA_HERE; // File | 
$imageFields = ; // array[File] | 
$id = 789; // Long | id of the game

try {
    $result = $api_instance->editGame($game, $imageField, $imageFields, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->editGame: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $game = ; # Game | 
my $imageField = BINARY_DATA_HERE; # File | 
my $imageFields = []; # array[File] | 
my $id = 789; # Long | id of the game

eval {
    my $result = $api_instance->editGame(game => $game, imageField => $imageField, imageFields => $imageFields, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->editGame: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
game =  # Game |  (default to null)
imageField = BINARY_DATA_HERE # File |  (default to null)
imageFields =  # array[File] |  (default to null)
id = 789 # Long | id of the game (default to null)

try:
    # Edit a game
    api_response = api_instance.edit_game(game, imageField, imageFields, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->editGame: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let game = ; // Game
    let imageField = BINARY_DATA_HERE; // File
    let imageFields = ; // array[File]
    let id = 789; // Long

    let mut context = GameRestControllerApi::Context::default();
    let result = client.editGame(game, imageField, imageFields, id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the game

Required
Query parameters
Name Description
game*
Game
Required
imageField*
File (binary)
Required
imageFields*
array[File] (binary)
Required

Responses

Status: 404 - Game not found

Status: 200 - Game edited

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

gameDetails

Get a game by its id


/api/games/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | id of the game

        try {
            GameDetails result = apiInstance.gameDetails(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#gameDetails");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | id of the game

        try {
            GameDetails result = apiInstance.gameDetails(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#gameDetails");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Long *id = 789; // id of the game (default to null)

// Get a game by its id
[apiInstance gameDetailsWith:id
              completionHandler: ^(GameDetails output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var id = 789; // {Long} id of the game

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.gameDetails(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class gameDetailsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var id = 789;  // Long | id of the game (default to null)

            try {
                // Get a game by its id
                GameDetails result = apiInstance.gameDetails(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.gameDetails: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$id = 789; // Long | id of the game

try {
    $result = $api_instance->gameDetails($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->gameDetails: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $id = 789; # Long | id of the game

eval {
    my $result = $api_instance->gameDetails(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->gameDetails: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
id = 789 # Long | id of the game (default to null)

try:
    # Get a game by its id
    api_response = api_instance.game_details(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->gameDetails: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = GameRestControllerApi::Context::default();
    let result = client.gameDetails(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the game

Required

Responses

Status: 404 - Game not found

Status: 200 - Found the game

{
game:
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
reviews:
{
totalPages:
integer (int32)
totalElements:
integer (int64)
size:
integer (int32)
content:
[
{
id:
integer (int64)
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
game:
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
date:
string (date)
rating:
integer (int32)
comment:
string
]
number:
integer (int32)
sort:
{
empty:
sorted:
unsorted:
first:
boolean
last:
boolean
numberOfElements:
integer (int32)
pageable:
{
offset:
sort:
pageNumber:
pageSize:
paged:
unpaged:
empty:
boolean

Status: 403 - forbiden o dont have permissions

getGames

Get a page of games


/api/games/

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();

        try {
            Game result = apiInstance.getGames();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#getGames");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();

        try {
            Game result = apiInstance.getGames();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#getGames");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];

// Get a page of games
[apiInstance getGamesWithCompletionHandler: 
              ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGames(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getGamesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();

            try {
                // Get a page of games
                Game result = apiInstance.getGames();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.getGames: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();

try {
    $result = $api_instance->getGames();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->getGames: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();

eval {
    my $result = $api_instance->getGames();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->getGames: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()

try:
    # Get a page of games
    api_response = api_instance.get_games()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->getGames: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {

    let mut context = GameRestControllerApi::Context::default();
    let result = client.getGames(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Status: 404 - Games not found

Status: 200 - Found the games

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

getGraphics

Get the graphics of a game


/api/games/{id}/graphics

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/{id}/graphics"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | 

        try {
            'String' result = apiInstance.getGraphics(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#getGraphics");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Long id = 789; // Long | 

        try {
            'String' result = apiInstance.getGraphics(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#getGraphics");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Get the graphics of a game
[apiInstance getGraphicsWith:id
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var id = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getGraphics(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getGraphicsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get the graphics of a game
                'String' result = apiInstance.getGraphics(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.getGraphics: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->getGraphics($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->getGraphics: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->getGraphics(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->getGraphics: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Get the graphics of a game
    api_response = api_instance.get_graphics(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->getGraphics: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = GameRestControllerApi::Context::default();
    let result = client.getGraphics(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 404 - Game not found

Status: 200 - Found the praphics of the game

string

getMoreFoundGames

Get more games by name or category


/api/games/moreFoundGames/{page}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/moreFoundGames/{page}?category=category_example&name=name_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Integer page = 56; // Integer | page of games
        String category = category_example; // String | 
        String name = name_example; // String | 

        try {
            Game result = apiInstance.getMoreFoundGames(page, category, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#getMoreFoundGames");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Integer page = 56; // Integer | page of games
        String category = category_example; // String | 
        String name = name_example; // String | 

        try {
            Game result = apiInstance.getMoreFoundGames(page, category, name);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#getMoreFoundGames");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Integer *page = 56; // page of games (default to null)
String *category = category_example; //  (default to null)
String *name = name_example; //  (default to null)

// Get more games by name or category
[apiInstance getMoreFoundGamesWith:page
    category:category
    name:name
              completionHandler: ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var page = 56; // {Integer} page of games
var category = category_example; // {String} 
var name = name_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMoreFoundGames(page, category, name, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getMoreFoundGamesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var page = 56;  // Integer | page of games (default to null)
            var category = category_example;  // String |  (default to null)
            var name = name_example;  // String |  (default to null)

            try {
                // Get more games by name or category
                Game result = apiInstance.getMoreFoundGames(page, category, name);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.getMoreFoundGames: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$page = 56; // Integer | page of games
$category = category_example; // String | 
$name = name_example; // String | 

try {
    $result = $api_instance->getMoreFoundGames($page, $category, $name);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->getMoreFoundGames: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $page = 56; # Integer | page of games
my $category = category_example; # String | 
my $name = name_example; # String | 

eval {
    my $result = $api_instance->getMoreFoundGames(page => $page, category => $category, name => $name);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->getMoreFoundGames: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
page = 56 # Integer | page of games (default to null)
category = category_example # String |  (default to null)
name = name_example # String |  (default to null)

try:
    # Get more games by name or category
    api_response = api_instance.get_more_found_games(page, category, name)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->getMoreFoundGames: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let page = 56; // Integer
    let category = category_example; // String
    let name = name_example; // String

    let mut context = GameRestControllerApi::Context::default();
    let result = client.getMoreFoundGames(page, category, name, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
page*
Integer (int32)

page of games

Required
Query parameters
Name Description
category*
String
Required
name*
String
Required

Responses

Status: 404 - Games not found

Status: 200 - Found the games by name or category

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

getMoreIndexGames

Get more games


/api/games/moreIndexGames/{page}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/moreIndexGames/{page}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Integer page = 56; // Integer | 

        try {
            Game result = apiInstance.getMoreIndexGames(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#getMoreIndexGames");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Integer page = 56; // Integer | 

        try {
            Game result = apiInstance.getMoreIndexGames(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#getMoreIndexGames");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Integer *page = 56; //  (default to null)

// Get more games
[apiInstance getMoreIndexGamesWith:page
              completionHandler: ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var page = 56; // {Integer} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMoreIndexGames(page, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getMoreIndexGamesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var page = 56;  // Integer |  (default to null)

            try {
                // Get more games
                Game result = apiInstance.getMoreIndexGames(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.getMoreIndexGames: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$page = 56; // Integer | 

try {
    $result = $api_instance->getMoreIndexGames($page);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->getMoreIndexGames: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $page = 56; # Integer | 

eval {
    my $result = $api_instance->getMoreIndexGames(page => $page);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->getMoreIndexGames: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
page = 56 # Integer |  (default to null)

try:
    # Get more games
    api_response = api_instance.get_more_index_games(page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->getMoreIndexGames: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = GameRestControllerApi::Context::default();
    let result = client.getMoreIndexGames(page, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
page*
Integer (int32)
Required

Responses

Status: 404 - Games not found

Status: 200 - Found the games

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

newGameProcess

Creates a new game


/api/games/

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/games/?game=&imageField=BINARY_DATA_HERE&imageFields="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.GameRestControllerApi;

import java.io.File;
import java.util.*;

public class GameRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Game game = ; // Game | 
        File imageField = BINARY_DATA_HERE; // File | 
        array[File] imageFields = ; // array[File] | 

        try {
            Game result = apiInstance.newGameProcess(game, imageField, imageFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#newGameProcess");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.GameRestControllerApi;

public class GameRestControllerApiExample {
    public static void main(String[] args) {
        GameRestControllerApi apiInstance = new GameRestControllerApi();
        Game game = ; // Game | 
        File imageField = BINARY_DATA_HERE; // File | 
        array[File] imageFields = ; // array[File] | 

        try {
            Game result = apiInstance.newGameProcess(game, imageField, imageFields);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GameRestControllerApi#newGameProcess");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
GameRestControllerApi *apiInstance = [[GameRestControllerApi alloc] init];
Game *game = ; //  (default to null)
File *imageField = BINARY_DATA_HERE; //  (default to null)
array[File] *imageFields = ; //  (default to null)

// Creates a new game
[apiInstance newGameProcessWith:game
    imageField:imageField
    imageFields:imageFields
              completionHandler: ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.GameRestControllerApi()
var game = ; // {Game} 
var imageField = BINARY_DATA_HERE; // {File} 
var imageFields = ; // {array[File]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.newGameProcess(game, imageField, imageFields, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class newGameProcessExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new GameRestControllerApi();
            var game = new Game(); // Game |  (default to null)
            var imageField = BINARY_DATA_HERE;  // File |  (default to null)
            var imageFields = new array[File](); // array[File] |  (default to null)

            try {
                // Creates a new game
                Game result = apiInstance.newGameProcess(game, imageField, imageFields);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GameRestControllerApi.newGameProcess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GameRestControllerApi();
$game = ; // Game | 
$imageField = BINARY_DATA_HERE; // File | 
$imageFields = ; // array[File] | 

try {
    $result = $api_instance->newGameProcess($game, $imageField, $imageFields);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GameRestControllerApi->newGameProcess: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::GameRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GameRestControllerApi->new();
my $game = ; # Game | 
my $imageField = BINARY_DATA_HERE; # File | 
my $imageFields = []; # array[File] | 

eval {
    my $result = $api_instance->newGameProcess(game => $game, imageField => $imageField, imageFields => $imageFields);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GameRestControllerApi->newGameProcess: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.GameRestControllerApi()
game =  # Game |  (default to null)
imageField = BINARY_DATA_HERE # File |  (default to null)
imageFields =  # array[File] |  (default to null)

try:
    # Creates a new game
    api_response = api_instance.new_game_process(game, imageField, imageFields)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GameRestControllerApi->newGameProcess: %s\n" % e)
extern crate GameRestControllerApi;

pub fn main() {
    let game = ; // Game
    let imageField = BINARY_DATA_HERE; // File
    let imageFields = ; // array[File]

    let mut context = GameRestControllerApi::Context::default();
    let result = client.newGameProcess(game, imageField, imageFields, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
game*
Game
Required
imageField*
File (binary)
Required
imageFields*
array[File] (binary)
Required

Responses

Status: 404 - Not Found

Status: 201 - Game created

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

LoginRestController

logOut

Log out 


/api/auth/logout

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/auth/logout"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginRestControllerApi;

import java.io.File;
import java.util.*;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#logOut");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.LoginRestControllerApi;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#logOut");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LoginRestControllerApi *apiInstance = [[LoginRestControllerApi alloc] init];

// Log out 
[apiInstance logOutWithCompletionHandler: 
              ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.logOut(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class logOutExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();

            try {
                // Log out 
                AuthResponse result = apiInstance.logOut();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.logOut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginRestControllerApi();

try {
    $result = $api_instance->logOut();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginRestControllerApi->logOut: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestControllerApi->new();

eval {
    my $result = $api_instance->logOut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestControllerApi->logOut: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()

try:
    # Log out 
    api_response = api_instance.log_out()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginRestControllerApi->logOut: %s\n" % e)
extern crate LoginRestControllerApi;

pub fn main() {

    let mut context = LoginRestControllerApi::Context::default();
    let result = client.logOut(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Status: 404 - Not Found

Status: 200 - Logout successful

{
status:
string
Enum: SUCCESS, FAILURE
message:
string
error:
string

login

log in to the application


/api/auth/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/auth/login" \
 -d '{
  "password" : "password",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginRestControllerApi;

import java.io.File;
import java.util.*;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 
        String accessToken = accessToken_example; // String | 
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#login");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.LoginRestControllerApi;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 
        String accessToken = accessToken_example; // String | 
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#login");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
LoginRestControllerApi *apiInstance = [[LoginRestControllerApi alloc] init];
LoginRequest *loginRequest = ; // 
String *accessToken = accessToken_example; //  (optional) (default to null)
String *refreshToken = refreshToken_example; //  (optional) (default to null)

// log in to the application
[apiInstance loginWith:loginRequest
    accessToken:accessToken
    refreshToken:refreshToken
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var loginRequest = ; // {LoginRequest} 
var opts = {
  'accessToken': accessToken_example, // {String} 
  'refreshToken': refreshToken_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(loginRequest, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 
            var accessToken = accessToken_example;  // String |  (optional)  (default to null)
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

            try {
                // log in to the application
                AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.login: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginRestControllerApi();
$loginRequest = ; // LoginRequest | 
$accessToken = accessToken_example; // String | 
$refreshToken = refreshToken_example; // String | 

try {
    $result = $api_instance->login($loginRequest, $accessToken, $refreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginRestControllerApi->login: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestControllerApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 
my $accessToken = accessToken_example; # String | 
my $refreshToken = refreshToken_example; # String | 

eval {
    my $result = $api_instance->login(loginRequest => $loginRequest, accessToken => $accessToken, refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestControllerApi->login: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()
loginRequest =  # LoginRequest | 
accessToken = accessToken_example # String |  (optional) (default to null)
refreshToken = refreshToken_example # String |  (optional) (default to null)

try:
    # log in to the application
    api_response = api_instance.login(loginRequest, accessToken=accessToken, refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginRestControllerApi->login: %s\n" % e)
extern crate LoginRestControllerApi;

pub fn main() {
    let loginRequest = ; // LoginRequest
    let accessToken = accessToken_example; // String
    let refreshToken = refreshToken_example; // String

    let mut context = LoginRestControllerApi::Context::default();
    let result = client.login(loginRequest, accessToken, refreshToken, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters
Name Description
loginRequest *

{
username:
string
password:
string

Responses

Status: 404 - Not Found

Status: 200 - Login successful

{
status:
string
Enum: SUCCESS, FAILURE
message:
string
error:
string

ReviewRestController

addReview

Add a review to a game


/api/reviews/{gameId}/{userId}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/reviews/{gameId}/{userId}?comment=comment_example&reviewRate=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReviewRestControllerApi;

import java.io.File;
import java.util.*;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long gameId = 789; // Long | Id of the game
        Long userId = 789; // Long | Id of the user
        String comment = comment_example; // String | 
        Integer reviewRate = 56; // Integer | 

        try {
            Review result = apiInstance.addReview(gameId, userId, comment, reviewRate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#addReview");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long gameId = 789; // Long | Id of the game
        Long userId = 789; // Long | Id of the user
        String comment = comment_example; // String | 
        Integer reviewRate = 56; // Integer | 

        try {
            Review result = apiInstance.addReview(gameId, userId, comment, reviewRate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#addReview");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Long *gameId = 789; // Id of the game (default to null)
Long *userId = 789; // Id of the user (default to null)
String *comment = comment_example; //  (default to null)
Integer *reviewRate = 56; //  (default to null)

// Add a review to a game
[apiInstance addReviewWith:gameId
    userId:userId
    comment:comment
    reviewRate:reviewRate
              completionHandler: ^(Review output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var gameId = 789; // {Long} Id of the game
var userId = 789; // {Long} Id of the user
var comment = comment_example; // {String} 
var reviewRate = 56; // {Integer} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addReview(gameId, userId, comment, reviewRate, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addReviewExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var gameId = 789;  // Long | Id of the game (default to null)
            var userId = 789;  // Long | Id of the user (default to null)
            var comment = comment_example;  // String |  (default to null)
            var reviewRate = 56;  // Integer |  (default to null)

            try {
                // Add a review to a game
                Review result = apiInstance.addReview(gameId, userId, comment, reviewRate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.addReview: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$gameId = 789; // Long | Id of the game
$userId = 789; // Long | Id of the user
$comment = comment_example; // String | 
$reviewRate = 56; // Integer | 

try {
    $result = $api_instance->addReview($gameId, $userId, $comment, $reviewRate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->addReview: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $gameId = 789; # Long | Id of the game
my $userId = 789; # Long | Id of the user
my $comment = comment_example; # String | 
my $reviewRate = 56; # Integer | 

eval {
    my $result = $api_instance->addReview(gameId => $gameId, userId => $userId, comment => $comment, reviewRate => $reviewRate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->addReview: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
gameId = 789 # Long | Id of the game (default to null)
userId = 789 # Long | Id of the user (default to null)
comment = comment_example # String |  (default to null)
reviewRate = 56 # Integer |  (default to null)

try:
    # Add a review to a game
    api_response = api_instance.add_review(gameId, userId, comment, reviewRate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->addReview: %s\n" % e)
extern crate ReviewRestControllerApi;

pub fn main() {
    let gameId = 789; // Long
    let userId = 789; // Long
    let comment = comment_example; // String
    let reviewRate = 56; // Integer

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.addReview(gameId, userId, comment, reviewRate, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
gameId*
Long (int64)

Id of the game

Required
userId*
Long (int64)

Id of the user

Required
Query parameters
Name Description
comment*
String
Required
reviewRate*
Integer (int32)
Required

Responses

Status: 404 - Game not found

Status: 403 - forbiden o dont have permissions

Status: 201 - Review added

{
id:
integer (int64)
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
game:
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
date:
string (date)
rating:
integer (int32)
comment:
string

deleteReview

Delete a review


/api/reviews/{reviewId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/reviews/{reviewId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReviewRestControllerApi;

import java.io.File;
import java.util.*;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long reviewId = 789; // Long | Id of the review

        try {
            Review result = apiInstance.deleteReview(reviewId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReview");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long reviewId = 789; // Long | Id of the review

        try {
            Review result = apiInstance.deleteReview(reviewId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReview");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Long *reviewId = 789; // Id of the review (default to null)

// Delete a review
[apiInstance deleteReviewWith:reviewId
              completionHandler: ^(Review output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var reviewId = 789; // {Long} Id of the review

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteReview(reviewId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteReviewExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var reviewId = 789;  // Long | Id of the review (default to null)

            try {
                // Delete a review
                Review result = apiInstance.deleteReview(reviewId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.deleteReview: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$reviewId = 789; // Long | Id of the review

try {
    $result = $api_instance->deleteReview($reviewId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->deleteReview: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $reviewId = 789; # Long | Id of the review

eval {
    my $result = $api_instance->deleteReview(reviewId => $reviewId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->deleteReview: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
reviewId = 789 # Long | Id of the review (default to null)

try:
    # Delete a review
    api_response = api_instance.delete_review(reviewId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->deleteReview: %s\n" % e)
extern crate ReviewRestControllerApi;

pub fn main() {
    let reviewId = 789; // Long

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.deleteReview(reviewId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
reviewId*
Long (int64)

Id of the review

Required

Responses

Status: 404 - Review not found

Status: 403 - forbiden o dont have permissions

Status: 200 - Review deleted

{
id:
integer (int64)
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
game:
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
date:
string (date)
rating:
integer (int32)
comment:
string

getMoreReviews

Get more reviews of a game


/api/reviews/more/{id}/{page}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/reviews/more/{id}/{page}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReviewRestControllerApi;

import java.io.File;
import java.util.*;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Integer page = 56; // Integer | Page number
        Long id = 789; // Long | Game id

        try {
            Review result = apiInstance.getMoreReviews(page, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getMoreReviews");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Integer page = 56; // Integer | Page number
        Long id = 789; // Long | Game id

        try {
            Review result = apiInstance.getMoreReviews(page, id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getMoreReviews");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Integer *page = 56; // Page number (default to null)
Long *id = 789; // Game id (default to null)

// Get more reviews of a game
[apiInstance getMoreReviewsWith:page
    id:id
              completionHandler: ^(Review output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var page = 56; // {Integer} Page number
var id = 789; // {Long} Game id

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMoreReviews(page, id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getMoreReviewsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var page = 56;  // Integer | Page number (default to null)
            var id = 789;  // Long | Game id (default to null)

            try {
                // Get more reviews of a game
                Review result = apiInstance.getMoreReviews(page, id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getMoreReviews: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$page = 56; // Integer | Page number
$id = 789; // Long | Game id

try {
    $result = $api_instance->getMoreReviews($page, $id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->getMoreReviews: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $page = 56; # Integer | Page number
my $id = 789; # Long | Game id

eval {
    my $result = $api_instance->getMoreReviews(page => $page, id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->getMoreReviews: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
page = 56 # Integer | Page number (default to null)
id = 789 # Long | Game id (default to null)

try:
    # Get more reviews of a game
    api_response = api_instance.get_more_reviews(page, id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getMoreReviews: %s\n" % e)
extern crate ReviewRestControllerApi;

pub fn main() {
    let page = 56; // Integer
    let id = 789; // Long

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.getMoreReviews(page, id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
page*
Integer (int32)

Page number

Required
id*
Long (int64)

Game id

Required

Responses

Status: 404 - Game not found

Status: 200 - More reviews

{
id:
integer (int64)
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
game:
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
date:
string (date)
rating:
integer (int32)
comment:
string

getReview

Get a review


/api/reviews/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/reviews/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ReviewRestControllerApi;

import java.io.File;
import java.util.*;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long id = 789; // Long | Id of the user

        try {
            Review result = apiInstance.getReview(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getReview");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long id = 789; // Long | Id of the user

        try {
            Review result = apiInstance.getReview(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getReview");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Long *id = 789; // Id of the user (default to null)

// Get a review
[apiInstance getReviewWith:id
              completionHandler: ^(Review output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var id = 789; // {Long} Id of the user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getReview(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getReviewExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var id = 789;  // Long | Id of the user (default to null)

            try {
                // Get a review
                Review result = apiInstance.getReview(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getReview: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$id = 789; // Long | Id of the user

try {
    $result = $api_instance->getReview($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->getReview: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $id = 789; # Long | Id of the user

eval {
    my $result = $api_instance->getReview(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->getReview: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
id = 789 # Long | Id of the user (default to null)

try:
    # Get a review
    api_response = api_instance.get_review(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getReview: %s\n" % e)
extern crate ReviewRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.getReview(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

Id of the user

Required

Responses

Status: 404 - Review not found

Status: 200 - Review

{
id:
integer (int64)
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
game:
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
date:
string (date)
rating:
integer (int32)
comment:
string

UserRestController

addCart

Add a game to the cart of the user


/api/users/{userId}/cart/{id}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/{userId}/cart/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | id of the game
        Long userId = 789; // Long | id of the current user

        try {
            UserProfile result = apiInstance.addCart(id, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#addCart");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | id of the game
        Long userId = 789; // Long | id of the current user

        try {
            UserProfile result = apiInstance.addCart(id, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#addCart");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; // id of the game (default to null)
Long *userId = 789; // id of the current user (default to null)

// Add a game to the cart of the user
[apiInstance addCartWith:id
    userId:userId
              completionHandler: ^(UserProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} id of the game
var userId = 789; // {Long} id of the current user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addCart(id, userId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class addCartExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long | id of the game (default to null)
            var userId = 789;  // Long | id of the current user (default to null)

            try {
                // Add a game to the cart of the user
                UserProfile result = apiInstance.addCart(id, userId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.addCart: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | id of the game
$userId = 789; // Long | id of the current user

try {
    $result = $api_instance->addCart($id, $userId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->addCart: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | id of the game
my $userId = 789; # Long | id of the current user

eval {
    my $result = $api_instance->addCart(id => $id, userId => $userId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->addCart: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long | id of the game (default to null)
userId = 789 # Long | id of the current user (default to null)

try:
    # Add a game to the cart of the user
    api_response = api_instance.add_cart(id, userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->addCart: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let userId = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.addCart(id, userId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the game

Required
userId*
Long (int64)

id of the current user

Required

Responses

Status: 404 - Game not found

Status: 403 - forbiden o dont have permissions

Status: 201 - Game added to the cart

{
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
games:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
]

cart

Get the cart of the user


/api/users/{userId}/cart

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/{userId}/cart"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long userId = 789; // Long | id of the current user

        try {
            UserProfile result = apiInstance.cart(userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#cart");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long userId = 789; // Long | id of the current user

        try {
            UserProfile result = apiInstance.cart(userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#cart");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *userId = 789; // id of the current user (default to null)

// Get the cart of the user
[apiInstance cartWith:userId
              completionHandler: ^(UserProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var userId = 789; // {Long} id of the current user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cart(userId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cartExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var userId = 789;  // Long | id of the current user (default to null)

            try {
                // Get the cart of the user
                UserProfile result = apiInstance.cart(userId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.cart: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$userId = 789; // Long | id of the current user

try {
    $result = $api_instance->cart($userId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->cart: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $userId = 789; # Long | id of the current user

eval {
    my $result = $api_instance->cart(userId => $userId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->cart: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
userId = 789 # Long | id of the current user (default to null)

try:
    # Get the cart of the user
    api_response = api_instance.cart(userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->cart: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let userId = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.cart(userId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
userId*
Long (int64)

id of the current user

Required

Responses

Status: 404 - Cart not found

Status: 200 - Found the cart

{
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
games:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
]

checkoutProcess

make a purchase


/api/users/{userId}/checkout

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/{userId}/checkout?billing_street=billingStreet_example&billing_apartment=billingApartment_example&billing_city=billingCity_example&billing_country=billingCountry_example&billing_postcode=billingPostcode_example&billing_phone=billingPhone_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        String billingStreet = billingStreet_example; // String | 
        String billingApartment = billingApartment_example; // String | 
        String billingCity = billingCity_example; // String | 
        String billingCountry = billingCountry_example; // String | 
        String billingPostcode = billingPostcode_example; // String | 
        String billingPhone = billingPhone_example; // String | 
        Long userId = 789; // Long | id of the current user

        try {
            UserProfile result = apiInstance.checkoutProcess(billingStreet, billingApartment, billingCity, billingCountry, billingPostcode, billingPhone, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#checkoutProcess");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        String billingStreet = billingStreet_example; // String | 
        String billingApartment = billingApartment_example; // String | 
        String billingCity = billingCity_example; // String | 
        String billingCountry = billingCountry_example; // String | 
        String billingPostcode = billingPostcode_example; // String | 
        String billingPhone = billingPhone_example; // String | 
        Long userId = 789; // Long | id of the current user

        try {
            UserProfile result = apiInstance.checkoutProcess(billingStreet, billingApartment, billingCity, billingCountry, billingPostcode, billingPhone, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#checkoutProcess");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
String *billingStreet = billingStreet_example; //  (default to null)
String *billingApartment = billingApartment_example; //  (default to null)
String *billingCity = billingCity_example; //  (default to null)
String *billingCountry = billingCountry_example; //  (default to null)
String *billingPostcode = billingPostcode_example; //  (default to null)
String *billingPhone = billingPhone_example; //  (default to null)
Long *userId = 789; // id of the current user (default to null)

// make a purchase
[apiInstance checkoutProcessWith:billingStreet
    billingApartment:billingApartment
    billingCity:billingCity
    billingCountry:billingCountry
    billingPostcode:billingPostcode
    billingPhone:billingPhone
    userId:userId
              completionHandler: ^(UserProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var billingStreet = billingStreet_example; // {String} 
var billingApartment = billingApartment_example; // {String} 
var billingCity = billingCity_example; // {String} 
var billingCountry = billingCountry_example; // {String} 
var billingPostcode = billingPostcode_example; // {String} 
var billingPhone = billingPhone_example; // {String} 
var userId = 789; // {Long} id of the current user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.checkoutProcess(billingStreet, billingApartment, billingCity, billingCountry, billingPostcode, billingPhone, userId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class checkoutProcessExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var billingStreet = billingStreet_example;  // String |  (default to null)
            var billingApartment = billingApartment_example;  // String |  (default to null)
            var billingCity = billingCity_example;  // String |  (default to null)
            var billingCountry = billingCountry_example;  // String |  (default to null)
            var billingPostcode = billingPostcode_example;  // String |  (default to null)
            var billingPhone = billingPhone_example;  // String |  (default to null)
            var userId = 789;  // Long | id of the current user (default to null)

            try {
                // make a purchase
                UserProfile result = apiInstance.checkoutProcess(billingStreet, billingApartment, billingCity, billingCountry, billingPostcode, billingPhone, userId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.checkoutProcess: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$billingStreet = billingStreet_example; // String | 
$billingApartment = billingApartment_example; // String | 
$billingCity = billingCity_example; // String | 
$billingCountry = billingCountry_example; // String | 
$billingPostcode = billingPostcode_example; // String | 
$billingPhone = billingPhone_example; // String | 
$userId = 789; // Long | id of the current user

try {
    $result = $api_instance->checkoutProcess($billingStreet, $billingApartment, $billingCity, $billingCountry, $billingPostcode, $billingPhone, $userId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->checkoutProcess: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $billingStreet = billingStreet_example; # String | 
my $billingApartment = billingApartment_example; # String | 
my $billingCity = billingCity_example; # String | 
my $billingCountry = billingCountry_example; # String | 
my $billingPostcode = billingPostcode_example; # String | 
my $billingPhone = billingPhone_example; # String | 
my $userId = 789; # Long | id of the current user

eval {
    my $result = $api_instance->checkoutProcess(billingStreet => $billingStreet, billingApartment => $billingApartment, billingCity => $billingCity, billingCountry => $billingCountry, billingPostcode => $billingPostcode, billingPhone => $billingPhone, userId => $userId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->checkoutProcess: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
billingStreet = billingStreet_example # String |  (default to null)
billingApartment = billingApartment_example # String |  (default to null)
billingCity = billingCity_example # String |  (default to null)
billingCountry = billingCountry_example # String |  (default to null)
billingPostcode = billingPostcode_example # String |  (default to null)
billingPhone = billingPhone_example # String |  (default to null)
userId = 789 # Long | id of the current user (default to null)

try:
    # make a purchase
    api_response = api_instance.checkout_process(billingStreet, billingApartment, billingCity, billingCountry, billingPostcode, billingPhone, userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->checkoutProcess: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let billingStreet = billingStreet_example; // String
    let billingApartment = billingApartment_example; // String
    let billingCity = billingCity_example; // String
    let billingCountry = billingCountry_example; // String
    let billingPostcode = billingPostcode_example; // String
    let billingPhone = billingPhone_example; // String
    let userId = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.checkoutProcess(billingStreet, billingApartment, billingCity, billingCountry, billingPostcode, billingPhone, userId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
userId*
Long (int64)

id of the current user

Required
Query parameters
Name Description
billing_street*
String
Required
billing_apartment*
String
Required
billing_city*
String
Required
billing_country*
String
Required
billing_postcode*
String
Required
billing_phone*
String
Required

Responses

Status: 404 - Game not found

Status: 403 - forbiden o dont have permissions

Status: 201 - the purchase has been successfully completed

{
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
games:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
]

deleteCart

Delete a game to the cart of the user


/api/users/{userId}/cart/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/{userId}/cart/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | id of the game
        Long userId = 789; // Long | id of the current user

        try {
            UserProfile result = apiInstance.deleteCart(id, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteCart");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | id of the game
        Long userId = 789; // Long | id of the current user

        try {
            UserProfile result = apiInstance.deleteCart(id, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteCart");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; // id of the game (default to null)
Long *userId = 789; // id of the current user (default to null)

// Delete a game to the cart of the user
[apiInstance deleteCartWith:id
    userId:userId
              completionHandler: ^(UserProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} id of the game
var userId = 789; // {Long} id of the current user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteCart(id, userId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteCartExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long | id of the game (default to null)
            var userId = 789;  // Long | id of the current user (default to null)

            try {
                // Delete a game to the cart of the user
                UserProfile result = apiInstance.deleteCart(id, userId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteCart: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | id of the game
$userId = 789; // Long | id of the current user

try {
    $result = $api_instance->deleteCart($id, $userId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->deleteCart: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | id of the game
my $userId = 789; # Long | id of the current user

eval {
    my $result = $api_instance->deleteCart(id => $id, userId => $userId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->deleteCart: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long | id of the game (default to null)
userId = 789 # Long | id of the current user (default to null)

try:
    # Delete a game to the cart of the user
    api_response = api_instance.delete_cart(id, userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteCart: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let userId = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.deleteCart(id, userId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the game

Required
userId*
Long (int64)

id of the current user

Required

Responses

Status: 404 - Game not found

Status: 403 - forbiden o dont have permissions

Status: 200 - Game deleted to the cart

{
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
games:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
]

downloadImageProfile

Get the image profile of the user


/api/users/{id}/imageProfile

Usage and SDK Samples

curl -X GET \
 -H "Accept: image/png" \
 "http://localhost:8443/api/users/{id}/imageProfile"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | id of the current user

        try {
            apiInstance.downloadImageProfile(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#downloadImageProfile");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | id of the current user

        try {
            apiInstance.downloadImageProfile(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#downloadImageProfile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; // id of the current user (default to null)

// Get the image profile of the user
[apiInstance downloadImageProfileWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} id of the current user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.downloadImageProfile(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class downloadImageProfileExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long | id of the current user (default to null)

            try {
                // Get the image profile of the user
                apiInstance.downloadImageProfile(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.downloadImageProfile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | id of the current user

try {
    $api_instance->downloadImageProfile($id);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->downloadImageProfile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | id of the current user

eval {
    $api_instance->downloadImageProfile(id => $id);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->downloadImageProfile: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long | id of the current user (default to null)

try:
    # Get the image profile of the user
    api_instance.download_image_profile(id)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->downloadImageProfile: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.downloadImageProfile(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the current user

Required

Responses

Status: 404 - image profile not found

Status: 403 - forbiden o dont have permissions

Status: 200 - Found the image profile

editProfile

Update the profile of the user


/api/users/{userId}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/{userId}?newUser=&imageFile=BINARY_DATA_HERE"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long userId = 789; // Long | id of the current user
        User newUser = ; // User | 
        File imageFile = BINARY_DATA_HERE; // File | 

        try {
            UserProfile result = apiInstance.editProfile(userId, newUser, imageFile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#editProfile");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long userId = 789; // Long | id of the current user
        User newUser = ; // User | 
        File imageFile = BINARY_DATA_HERE; // File | 

        try {
            UserProfile result = apiInstance.editProfile(userId, newUser, imageFile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#editProfile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *userId = 789; // id of the current user (default to null)
User *newUser = ; //  (default to null)
File *imageFile = BINARY_DATA_HERE; //  (default to null)

// Update the profile of the user
[apiInstance editProfileWith:userId
    newUser:newUser
    imageFile:imageFile
              completionHandler: ^(UserProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var userId = 789; // {Long} id of the current user
var newUser = ; // {User} 
var imageFile = BINARY_DATA_HERE; // {File} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.editProfile(userId, newUser, imageFile, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class editProfileExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var userId = 789;  // Long | id of the current user (default to null)
            var newUser = new User(); // User |  (default to null)
            var imageFile = BINARY_DATA_HERE;  // File |  (default to null)

            try {
                // Update the profile of the user
                UserProfile result = apiInstance.editProfile(userId, newUser, imageFile);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.editProfile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$userId = 789; // Long | id of the current user
$newUser = ; // User | 
$imageFile = BINARY_DATA_HERE; // File | 

try {
    $result = $api_instance->editProfile($userId, $newUser, $imageFile);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->editProfile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $userId = 789; # Long | id of the current user
my $newUser = ; # User | 
my $imageFile = BINARY_DATA_HERE; # File | 

eval {
    my $result = $api_instance->editProfile(userId => $userId, newUser => $newUser, imageFile => $imageFile);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->editProfile: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
userId = 789 # Long | id of the current user (default to null)
newUser =  # User |  (default to null)
imageFile = BINARY_DATA_HERE # File |  (default to null)

try:
    # Update the profile of the user
    api_response = api_instance.edit_profile(userId, newUser, imageFile)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->editProfile: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let userId = 789; // Long
    let newUser = ; // User
    let imageFile = BINARY_DATA_HERE; // File

    let mut context = UserRestControllerApi::Context::default();
    let result = client.editProfile(userId, newUser, imageFile, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
userId*
Long (int64)

id of the current user

Required
Query parameters
Name Description
newUser*
User
Required
imageFile*
File (binary)
Required

Responses

Status: 404 - Profile not found

Status: 403 - forbiden o dont have permissions

Status: 200 - Profile updated

{
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
games:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
]

getMoreCartGames

Get more cart games of the user


/api/users/{userId}/moreCartGames/{page}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/{userId}/moreCartGames/{page}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Integer page = 56; // Integer | page of the games
        Long userId = 789; // Long | id of the current user

        try {
            Game result = apiInstance.getMoreCartGames(page, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getMoreCartGames");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Integer page = 56; // Integer | page of the games
        Long userId = 789; // Long | id of the current user

        try {
            Game result = apiInstance.getMoreCartGames(page, userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getMoreCartGames");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Integer *page = 56; // page of the games (default to null)
Long *userId = 789; // id of the current user (default to null)

// Get more cart games of the user
[apiInstance getMoreCartGamesWith:page
    userId:userId
              completionHandler: ^(Game output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var page = 56; // {Integer} page of the games
var userId = 789; // {Long} id of the current user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMoreCartGames(page, userId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getMoreCartGamesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var page = 56;  // Integer | page of the games (default to null)
            var userId = 789;  // Long | id of the current user (default to null)

            try {
                // Get more cart games of the user
                Game result = apiInstance.getMoreCartGames(page, userId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getMoreCartGames: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$page = 56; // Integer | page of the games
$userId = 789; // Long | id of the current user

try {
    $result = $api_instance->getMoreCartGames($page, $userId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getMoreCartGames: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $page = 56; # Integer | page of the games
my $userId = 789; # Long | id of the current user

eval {
    my $result = $api_instance->getMoreCartGames(page => $page, userId => $userId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getMoreCartGames: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
page = 56 # Integer | page of the games (default to null)
userId = 789 # Long | id of the current user (default to null)

try:
    # Get more cart games of the user
    api_response = api_instance.get_more_cart_games(page, userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getMoreCartGames: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let page = 56; // Integer
    let userId = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getMoreCartGames(page, userId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
page*
Integer (int32)

page of the games

Required
userId*
Long (int64)

id of the current user

Required

Responses

Status: 404 - Games not found in the cart

Status: 200 - Found more games in the cart

{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]

getUser

Get user


/api/users/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | id of the user

        try {
            User result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUser");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | id of the user

        try {
            User result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUser");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; // id of the user (default to null)

// Get user
[apiInstance getUserWith:id
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} id of the user

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUser(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUserExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long | id of the user (default to null)

            try {
                // Get user
                User result = apiInstance.getUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | id of the user

try {
    $result = $api_instance->getUser($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUser: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | id of the user

eval {
    my $result = $api_instance->getUser(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUser: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long | id of the user (default to null)

try:
    # Get user
    api_response = api_instance.get_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUser: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUser(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)

id of the user

Required

Responses

Status: 404 - User not found

Status: 403 - forbiden o dont have permissions

Status: 200 - Found the user

{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)

profile

Get information about the current user


/api/users/me

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/me"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();

        try {
            UserProfile result = apiInstance.profile();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#profile");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();

        try {
            UserProfile result = apiInstance.profile();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#profile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];

// Get information about the current user
[apiInstance profileWithCompletionHandler: 
              ^(UserProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.profile(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class profileExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();

            try {
                // Get information about the current user
                UserProfile result = apiInstance.profile();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.profile: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();

try {
    $result = $api_instance->profile();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->profile: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();

eval {
    my $result = $api_instance->profile();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->profile: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()

try:
    # Get information about the current user
    api_response = api_instance.profile()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->profile: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.profile(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Status: 404 - User not found

Status: 403 - forbiden o dont have permissions

Status: 200 - Found the user

{
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
games:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
]

purchase

Get the purchase of the user


/api/users/{userId}/purchase/{purchaseId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/{userId}/purchase/{purchaseId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long userId = 789; // Long | id of the current user
        Long purchaseId = 789; // Long | id of the purchase

        try {
            Purchase result = apiInstance.purchase(userId, purchaseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#purchase");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long userId = 789; // Long | id of the current user
        Long purchaseId = 789; // Long | id of the purchase

        try {
            Purchase result = apiInstance.purchase(userId, purchaseId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#purchase");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *userId = 789; // id of the current user (default to null)
Long *purchaseId = 789; // id of the purchase (default to null)

// Get the purchase of the user
[apiInstance purchaseWith:userId
    purchaseId:purchaseId
              completionHandler: ^(Purchase output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var userId = 789; // {Long} id of the current user
var purchaseId = 789; // {Long} id of the purchase

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.purchase(userId, purchaseId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class purchaseExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var userId = 789;  // Long | id of the current user (default to null)
            var purchaseId = 789;  // Long | id of the purchase (default to null)

            try {
                // Get the purchase of the user
                Purchase result = apiInstance.purchase(userId, purchaseId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.purchase: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$userId = 789; // Long | id of the current user
$purchaseId = 789; // Long | id of the purchase

try {
    $result = $api_instance->purchase($userId, $purchaseId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->purchase: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $userId = 789; # Long | id of the current user
my $purchaseId = 789; # Long | id of the purchase

eval {
    my $result = $api_instance->purchase(userId => $userId, purchaseId => $purchaseId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->purchase: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
userId = 789 # Long | id of the current user (default to null)
purchaseId = 789 # Long | id of the purchase (default to null)

try:
    # Get the purchase of the user
    api_response = api_instance.purchase(userId, purchaseId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->purchase: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let userId = 789; // Long
    let purchaseId = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.purchase(userId, purchaseId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters
Name Description
userId*
Long (int64)

id of the current user

Required
purchaseId*
Long (int64)

id of the purchase

Required

Responses

Status: 404 - Purchase not found

Status: 403 - forbiden o dont have permissions

Status: 200 - Found the purchase

{
id:
integer (int64)
games:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
]
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
date:
string (date)

recomendations

Get recomendation tothe current user


/api/users/recomended

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/recomended?numberOfGames=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Integer numberOfGames = 56; // Integer | 

        try {
            UserProfile result = apiInstance.recomendations(numberOfGames);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#recomendations");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Integer numberOfGames = 56; // Integer | 

        try {
            UserProfile result = apiInstance.recomendations(numberOfGames);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#recomendations");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Integer *numberOfGames = 56; //  (default to null)

// Get recomendation tothe current user
[apiInstance recomendationsWith:numberOfGames
              completionHandler: ^(UserProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var numberOfGames = 56; // {Integer} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.recomendations(numberOfGames, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class recomendationsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var numberOfGames = 56;  // Integer |  (default to null)

            try {
                // Get recomendation tothe current user
                UserProfile result = apiInstance.recomendations(numberOfGames);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.recomendations: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$numberOfGames = 56; // Integer | 

try {
    $result = $api_instance->recomendations($numberOfGames);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->recomendations: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $numberOfGames = 56; # Integer | 

eval {
    my $result = $api_instance->recomendations(numberOfGames => $numberOfGames);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->recomendations: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
numberOfGames = 56 # Integer |  (default to null)

try:
    # Get recomendation tothe current user
    api_response = api_instance.recomendations(numberOfGames)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->recomendations: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let numberOfGames = 56; // Integer

    let mut context = UserRestControllerApi::Context::default();
    let result = client.recomendations(numberOfGames, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
numberOfGames*
Integer (int32)
Required

Responses

Status: 404 - Not found games recomendation

Status: 200 - Found games recomendations

{
user:
{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)
games:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (float)
category:
string
os:
string
processor:
string
memory:
string
graphics:
string
directX:
string
network:
string
hardDrive:
string
soundCard:
string
deleted:
boolean
totalRating:
integer (int32)
starDistribution:
[
integer (int32)
]
gameplayImages:
[
string
]
titleImage:
string
reviewCount:
integer (int32)
starDistributionInt:
[
integer (int32)
]
]

register

Register a new user


/api/users/

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/?name=name_example&lastName=lastName_example&mail=mail_example&password=password_example&aboutMe=aboutMe_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        String name = name_example; // String | 
        String lastName = lastName_example; // String | 
        String mail = mail_example; // String | 
        String password = password_example; // String | 
        String aboutMe = aboutMe_example; // String | 

        try {
            User result = apiInstance.register(name, lastName, mail, password, aboutMe);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#register");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        String name = name_example; // String | 
        String lastName = lastName_example; // String | 
        String mail = mail_example; // String | 
        String password = password_example; // String | 
        String aboutMe = aboutMe_example; // String | 

        try {
            User result = apiInstance.register(name, lastName, mail, password, aboutMe);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#register");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
String *name = name_example; //  (default to null)
String *lastName = lastName_example; //  (default to null)
String *mail = mail_example; //  (default to null)
String *password = password_example; //  (default to null)
String *aboutMe = aboutMe_example; //  (default to null)

// Register a new user
[apiInstance registerWith:name
    lastName:lastName
    mail:mail
    password:password
    aboutMe:aboutMe
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var name = name_example; // {String} 
var lastName = lastName_example; // {String} 
var mail = mail_example; // {String} 
var password = password_example; // {String} 
var aboutMe = aboutMe_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.register(name, lastName, mail, password, aboutMe, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class registerExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var name = name_example;  // String |  (default to null)
            var lastName = lastName_example;  // String |  (default to null)
            var mail = mail_example;  // String |  (default to null)
            var password = password_example;  // String |  (default to null)
            var aboutMe = aboutMe_example;  // String |  (default to null)

            try {
                // Register a new user
                User result = apiInstance.register(name, lastName, mail, password, aboutMe);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.register: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$name = name_example; // String | 
$lastName = lastName_example; // String | 
$mail = mail_example; // String | 
$password = password_example; // String | 
$aboutMe = aboutMe_example; // String | 

try {
    $result = $api_instance->register($name, $lastName, $mail, $password, $aboutMe);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->register: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $name = name_example; # String | 
my $lastName = lastName_example; # String | 
my $mail = mail_example; # String | 
my $password = password_example; # String | 
my $aboutMe = aboutMe_example; # String | 

eval {
    my $result = $api_instance->register(name => $name, lastName => $lastName, mail => $mail, password => $password, aboutMe => $aboutMe);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->register: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
name = name_example # String |  (default to null)
lastName = lastName_example # String |  (default to null)
mail = mail_example # String |  (default to null)
password = password_example # String |  (default to null)
aboutMe = aboutMe_example # String |  (default to null)

try:
    # Register a new user
    api_response = api_instance.register(name, lastName, mail, password, aboutMe)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->register: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let name = name_example; // String
    let lastName = lastName_example; // String
    let mail = mail_example; // String
    let password = password_example; // String
    let aboutMe = aboutMe_example; // String

    let mut context = UserRestControllerApi::Context::default();
    let result = client.register(name, lastName, mail, password, aboutMe, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters
Name Description
name*
String
Required
lastName*
String
Required
mail*
String
Required
password*
String
Required
aboutMe*
String
Required

Responses

Status: 404 - Not Found

Status: 403 - forbiden o dont have permissions

Status: 201 - User created

{
id:
integer (int64)
mail:
string
name:
string
lastName:
string
aboutMe:
string
billingInformation:
string
roles:
[
string
]
profilePircture:
string
totalPrice:
number (float)