OpenAPI definition

ClubRestController

createClub

/api/v1/clubs/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/clubs/" \
 -d '{
  "schedule" : {
    "closingTime" : "closingTime",
    "openingTime" : "openingTime"
  },
  "address" : "address",
  "sports" : [ {
    "modes" : [ {
      "name" : "name",
      "playersPerGame" : 6
    }, {
      "name" : "name",
      "playersPerGame" : 6
    } ],
    "scoringType" : "SCORE",
    "name" : "name",
    "id" : 0
  }, {
    "modes" : [ {
      "name" : "name",
      "playersPerGame" : 6
    }, {
      "name" : "name",
      "playersPerGame" : 6
    } ],
    "scoringType" : "SCORE",
    "name" : "name",
    "id" : 0
  } ],
  "city" : "city",
  "phone" : "phone",
  "web" : "web",
  "name" : "name",
  "numberOfCourts" : [ 5, 5 ],
  "id" : 0,
  "priceRange" : {
    "unit" : "unit",
    "minPrice" : 6.027456183070403,
    "maxPrice" : 1.4658129805029452
  },
  "email" : "email"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

        // Create an instance of the API class
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        ClubDTO clubDTO = ; // ClubDTO | 

        try {
            ClubDTO result = apiInstance.createClub(clubDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#createClub");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ClubDTO clubDTO = new ClubDTO(); // ClubDTO | 

try {
    final result = await api_instance.createClub(clubDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createClub: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

public class ClubRestControllerApiExample {
    public static void main(String[] args) {
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        ClubDTO clubDTO = ; // ClubDTO | 

        try {
            ClubDTO result = apiInstance.createClub(clubDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#createClub");
            e.printStackTrace();
        }
    }
}



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

[apiInstance createClubWith:clubDTO
              completionHandler: ^(ClubDTO 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.ClubRestControllerApi()
var clubDTO = ; // {ClubDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createClub(clubDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ClubRestControllerApi();
            var clubDTO = new ClubDTO(); // ClubDTO | 

            try {
                ClubDTO result = apiInstance.createClub(clubDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.createClub: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClubRestControllerApi();
$clubDTO = ; // ClubDTO | 

try {
    $result = $api_instance->createClub($clubDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->createClub: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClubRestControllerApi->new();
my $clubDTO = WWW::OPenAPIClient::Object::ClubDTO->new(); # ClubDTO | 

eval {
    my $result = $api_instance->createClub(clubDTO => $clubDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->createClub: $@\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.ClubRestControllerApi()
clubDTO =  # ClubDTO | 

try:
    api_response = api_instance.create_club(clubDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->createClub: %s\n" % e)

extern crate ClubRestControllerApi;

pub fn main() {
    let clubDTO = ; // ClubDTO

    let mut context = ClubRestControllerApi::Context::default();
    let result = client.createClub(clubDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
clubDTO *

Responses

Schema

createClubImage

/api/v1/clubs/{id}/image

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/clubs/{id}/image" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

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

        try {
            Object result = apiInstance.createClubImage(id, putUserImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#createClubImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final PutUserImageRequest putUserImageRequest = new PutUserImageRequest(); // PutUserImageRequest | 

try {
    final result = await api_instance.createClubImage(id, putUserImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createClubImage: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

public class ClubRestControllerApiExample {
    public static void main(String[] args) {
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        Long id = 789; // Long | 
        PutUserImageRequest putUserImageRequest = ; // PutUserImageRequest | 

        try {
            Object result = apiInstance.createClubImage(id, putUserImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#createClubImage");
            e.printStackTrace();
        }
    }
}



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

[apiInstance createClubImageWith:id
    putUserImageRequest:putUserImageRequest
              completionHandler: ^(Object 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.ClubRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'putUserImageRequest':  // {PutUserImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createClubImage(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.createClubImage(id, putUserImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.createClubImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->createClubImage($id, $putUserImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->createClubImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

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

eval {
    my $result = $api_instance->createClubImage(id => $id, putUserImageRequest => $putUserImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->createClubImage: $@\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.ClubRestControllerApi()
id = 789 # Long |  (default to null)
putUserImageRequest =  # PutUserImageRequest |  (optional)

try:
    api_response = api_instance.create_club_image(id, putUserImageRequest=putUserImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->createClubImage: %s\n" % e)

extern crate ClubRestControllerApi;

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

    let mut context = ClubRestControllerApi::Context::default();
    let result = client.createClubImage(id, putUserImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
putUserImageRequest

Responses

Schema

deleteClub

/api/v1/clubs/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/clubs/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteClub(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteClub: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

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

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



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

[apiInstance deleteClubWith:id
              completionHandler: ^(ClubDTO 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.ClubRestControllerApi()
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.deleteClub(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                ClubDTO result = apiInstance.deleteClub(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.deleteClub: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->deleteClub($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->deleteClub: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

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

eval {
    my $result = $api_instance->deleteClub(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->deleteClub: $@\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.ClubRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.delete_club(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->deleteClub: %s\n" % e)

extern crate ClubRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getClub

/api/v1/clubs/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/clubs/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getClub(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getClub: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

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

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



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

[apiInstance getClubWith:id
              completionHandler: ^(ClubDTO 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.ClubRestControllerApi()
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.getClub(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                ClubDTO result = apiInstance.getClub(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.getClub: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getClub($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->getClub: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

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

eval {
    my $result = $api_instance->getClub(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->getClub: $@\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.ClubRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_club(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->getClub: %s\n" % e)

extern crate ClubRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getClubImage

/api/v1/clubs/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/clubs/{id}/image"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getClubImage(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getClubImage: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

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

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



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

[apiInstance getClubImageWith:id
              completionHandler: ^(Object 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.ClubRestControllerApi()
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.getClubImage(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.getClubImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.getClubImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getClubImage($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->getClubImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

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

eval {
    my $result = $api_instance->getClubImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->getClubImage: $@\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.ClubRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_club_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->getClubImage: %s\n" % e)

extern crate ClubRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getClubs

/api/v1/clubs/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/clubs/?pageable="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

        // Create an instance of the API class
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageClubDTO result = apiInstance.getClubs(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#getClubs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 

try {
    final result = await api_instance.getClubs(pageable);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getClubs: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

public class ClubRestControllerApiExample {
    public static void main(String[] args) {
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageClubDTO result = apiInstance.getClubs(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#getClubs");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ClubRestControllerApi *apiInstance = [[ClubRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

[apiInstance getClubsWith:pageable
              completionHandler: ^(PageClubDTO 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.ClubRestControllerApi()
var pageable = ; // {Pageable} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getClubs(pageable, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ClubRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                PageClubDTO result = apiInstance.getClubs(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.getClubs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClubRestControllerApi();
$pageable = ; // Pageable | 

try {
    $result = $api_instance->getClubs($pageable);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->getClubs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

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

eval {
    my $result = $api_instance->getClubs(pageable => $pageable);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->getClubs: $@\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.ClubRestControllerApi()
pageable =  # Pageable |  (default to null)

try:
    api_response = api_instance.get_clubs(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->getClubs: %s\n" % e)

extern crate ClubRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable

    let mut context = ClubRestControllerApi::Context::default();
    let result = client.getClubs(pageable, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

getFilteredClubs

/api/v1/clubs

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/clubs?page=56&size=56&search=search_example&sport=sport_example&city=city_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

        // Create an instance of the API class
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 
        String search = search_example; // String | 
        String sport = sport_example; // String | 
        String city = city_example; // String | 

        try {
            PageClubDTO result = apiInstance.getFilteredClubs(page, size, search, sport, city);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#getFilteredClubs");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | 
final Integer size = new Integer(); // Integer | 
final String search = new String(); // String | 
final String sport = new String(); // String | 
final String city = new String(); // String | 

try {
    final result = await api_instance.getFilteredClubs(page, size, search, sport, city);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getFilteredClubs: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

public class ClubRestControllerApiExample {
    public static void main(String[] args) {
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 
        String search = search_example; // String | 
        String sport = sport_example; // String | 
        String city = city_example; // String | 

        try {
            PageClubDTO result = apiInstance.getFilteredClubs(page, size, search, sport, city);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#getFilteredClubs");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ClubRestControllerApi *apiInstance = [[ClubRestControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to 0)
Integer *size = 56; //  (optional) (default to 10)
String *search = search_example; //  (optional) (default to null)
String *sport = sport_example; //  (optional) (default to null)
String *city = city_example; //  (optional) (default to null)

[apiInstance getFilteredClubsWith:page
    size:size
    search:search
    sport:sport
    city:city
              completionHandler: ^(PageClubDTO 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.ClubRestControllerApi()
var opts = {
  'page': 56, // {Integer} 
  'size': 56, // {Integer} 
  'search': search_example, // {String} 
  'sport': sport_example, // {String} 
  'city': city_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFilteredClubs(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ClubRestControllerApi();
            var page = 56;  // Integer |  (optional)  (default to 0)
            var size = 56;  // Integer |  (optional)  (default to 10)
            var search = search_example;  // String |  (optional)  (default to null)
            var sport = sport_example;  // String |  (optional)  (default to null)
            var city = city_example;  // String |  (optional)  (default to null)

            try {
                PageClubDTO result = apiInstance.getFilteredClubs(page, size, search, sport, city);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.getFilteredClubs: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ClubRestControllerApi();
$page = 56; // Integer | 
$size = 56; // Integer | 
$search = search_example; // String | 
$sport = sport_example; // String | 
$city = city_example; // String | 

try {
    $result = $api_instance->getFilteredClubs($page, $size, $search, $sport, $city);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->getFilteredClubs: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ClubRestControllerApi->new();
my $page = 56; # Integer | 
my $size = 56; # Integer | 
my $search = search_example; # String | 
my $sport = sport_example; # String | 
my $city = city_example; # String | 

eval {
    my $result = $api_instance->getFilteredClubs(page => $page, size => $size, search => $search, sport => $sport, city => $city);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->getFilteredClubs: $@\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.ClubRestControllerApi()
page = 56 # Integer |  (optional) (default to 0)
size = 56 # Integer |  (optional) (default to 10)
search = search_example # String |  (optional) (default to null)
sport = sport_example # String |  (optional) (default to null)
city = city_example # String |  (optional) (default to null)

try:
    api_response = api_instance.get_filtered_clubs(page=page, size=size, search=search, sport=sport, city=city)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->getFilteredClubs: %s\n" % e)

extern crate ClubRestControllerApi;

pub fn main() {
    let page = 56; // Integer
    let size = 56; // Integer
    let search = search_example; // String
    let sport = sport_example; // String
    let city = city_example; // String

    let mut context = ClubRestControllerApi::Context::default();
    let result = client.getFilteredClubs(page, size, search, sport, city, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
page	Integer (int32)
size	Integer (int32)
search	String
sport	String
city	String

Responses

Schema

putclubImage

/api/v1/clubs/{id}/image

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/clubs/{id}/image" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

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

        try {
            Object result = apiInstance.putclubImage(id, putUserImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#putclubImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final PutUserImageRequest putUserImageRequest = new PutUserImageRequest(); // PutUserImageRequest | 

try {
    final result = await api_instance.putclubImage(id, putUserImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putclubImage: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

public class ClubRestControllerApiExample {
    public static void main(String[] args) {
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        Long id = 789; // Long | 
        PutUserImageRequest putUserImageRequest = ; // PutUserImageRequest | 

        try {
            Object result = apiInstance.putclubImage(id, putUserImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#putclubImage");
            e.printStackTrace();
        }
    }
}



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

[apiInstance putclubImageWith:id
    putUserImageRequest:putUserImageRequest
              completionHandler: ^(Object 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.ClubRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'putUserImageRequest':  // {PutUserImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.putclubImage(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.putclubImage(id, putUserImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.putclubImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->putclubImage($id, $putUserImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->putclubImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

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

eval {
    my $result = $api_instance->putclubImage(id => $id, putUserImageRequest => $putUserImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->putclubImage: $@\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.ClubRestControllerApi()
id = 789 # Long |  (default to null)
putUserImageRequest =  # PutUserImageRequest |  (optional)

try:
    api_response = api_instance.putclub_image(id, putUserImageRequest=putUserImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->putclubImage: %s\n" % e)

extern crate ClubRestControllerApi;

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

    let mut context = ClubRestControllerApi::Context::default();
    let result = client.putclubImage(id, putUserImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
putUserImageRequest

Responses

Schema

replaceClub

/api/v1/clubs/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/clubs/{id}" \
 -d '{
  "schedule" : {
    "closingTime" : "closingTime",
    "openingTime" : "openingTime"
  },
  "address" : "address",
  "sports" : [ {
    "modes" : [ {
      "name" : "name",
      "playersPerGame" : 6
    }, {
      "name" : "name",
      "playersPerGame" : 6
    } ],
    "scoringType" : "SCORE",
    "name" : "name",
    "id" : 0
  }, {
    "modes" : [ {
      "name" : "name",
      "playersPerGame" : 6
    }, {
      "name" : "name",
      "playersPerGame" : 6
    } ],
    "scoringType" : "SCORE",
    "name" : "name",
    "id" : 0
  } ],
  "city" : "city",
  "phone" : "phone",
  "web" : "web",
  "name" : "name",
  "numberOfCourts" : [ 5, 5 ],
  "id" : 0,
  "priceRange" : {
    "unit" : "unit",
    "minPrice" : 6.027456183070403,
    "maxPrice" : 1.4658129805029452
  },
  "email" : "email"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ClubRestControllerApi;

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

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

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

        try {
            ClubDTO result = apiInstance.replaceClub(id, clubDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#replaceClub");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ClubDTO clubDTO = new ClubDTO(); // ClubDTO | 

try {
    final result = await api_instance.replaceClub(id, clubDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceClub: $e\n');
}

import org.openapitools.client.api.ClubRestControllerApi;

public class ClubRestControllerApiExample {
    public static void main(String[] args) {
        ClubRestControllerApi apiInstance = new ClubRestControllerApi();
        Long id = 789; // Long | 
        ClubDTO clubDTO = ; // ClubDTO | 

        try {
            ClubDTO result = apiInstance.replaceClub(id, clubDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ClubRestControllerApi#replaceClub");
            e.printStackTrace();
        }
    }
}



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

[apiInstance replaceClubWith:id
    clubDTO:clubDTO
              completionHandler: ^(ClubDTO 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.ClubRestControllerApi()
var id = 789; // {Long} 
var clubDTO = ; // {ClubDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceClub(id, clubDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                ClubDTO result = apiInstance.replaceClub(id, clubDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ClubRestControllerApi.replaceClub: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->replaceClub($id, $clubDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ClubRestControllerApi->replaceClub: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ClubRestControllerApi;

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

eval {
    my $result = $api_instance->replaceClub(id => $id, clubDTO => $clubDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ClubRestControllerApi->replaceClub: $@\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.ClubRestControllerApi()
id = 789 # Long |  (default to null)
clubDTO =  # ClubDTO | 

try:
    api_response = api_instance.replace_club(id, clubDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ClubRestControllerApi->replaceClub: %s\n" % e)

extern crate ClubRestControllerApi;

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

    let mut context = ClubRestControllerApi::Context::default();
    let result = client.replaceClub(id, clubDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
clubDTO *

Responses

Schema

LoginController

logOut

/api/v1/auth/logout

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/auth/logout"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.logOut();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->logOut: $e\n');
}

import org.openapitools.client.api.LoginControllerApi;

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

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



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

[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.LoginControllerApi()
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 LoginControllerApi();

            try {
                AuthResponse result = apiInstance.logOut();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.logOut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->logOut();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginControllerApi->logOut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

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

eval {
    my $result = $api_instance->logOut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginControllerApi->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.LoginControllerApi()

try:
    api_response = api_instance.log_out()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->logOut: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

login

User login

Authenticates the user and returns JWT tokens (access and refresh).

/api/v1/auth/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,*/*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/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.LoginControllerApi;

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

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

        // Create an instance of the API class
        LoginControllerApi apiInstance = new LoginControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginRequest loginRequest = new LoginRequest(); // LoginRequest | 

try {
    final result = await api_instance.login(loginRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->login: $e\n');
}

import org.openapitools.client.api.LoginControllerApi;

public class LoginControllerApiExample {
    public static void main(String[] args) {
        LoginControllerApi apiInstance = new LoginControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 

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



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

// User login
[apiInstance loginWith:loginRequest
              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.LoginControllerApi()
var loginRequest = ; // {LoginRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(loginRequest, 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 LoginControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                // User login
                AuthResponse result = apiInstance.login(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.login: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginControllerApi();
$loginRequest = ; // LoginRequest | 

try {
    $result = $api_instance->login($loginRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginControllerApi->login: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginControllerApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 

eval {
    my $result = $api_instance->login(loginRequest => $loginRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginControllerApi->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.LoginControllerApi()
loginRequest =  # LoginRequest | 

try:
    # User login
    api_response = api_instance.login(loginRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->login: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {
    let loginRequest = ; // LoginRequest

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

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

Scopes

Parameters

Body parameters

Name	Description
loginRequest *

Responses

refreshToken

/api/v1/auth/refresh

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/auth/refresh"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

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

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

        // Create an instance of the API class
        LoginControllerApi apiInstance = new LoginControllerApi();
        String refreshToken = refreshToken_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String refreshToken = new String(); // String | 

try {
    final result = await api_instance.refreshToken(refreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->refreshToken: $e\n');
}

import org.openapitools.client.api.LoginControllerApi;

public class LoginControllerApiExample {
    public static void main(String[] args) {
        LoginControllerApi apiInstance = new LoginControllerApi();
        String refreshToken = refreshToken_example; // String | 

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



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

[apiInstance refreshTokenWith: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.LoginControllerApi()
var opts = {
  '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.refreshToken(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new LoginControllerApi();
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

            try {
                AuthResponse result = apiInstance.refreshToken(refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.refreshToken: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginControllerApi();
$refreshToken = refreshToken_example; // String | 

try {
    $result = $api_instance->refreshToken($refreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginControllerApi->refreshToken: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginControllerApi->new();
my $refreshToken = refreshToken_example; # String | 

eval {
    my $result = $api_instance->refreshToken(refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginControllerApi->refreshToken: $@\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.LoginControllerApi()
refreshToken = refreshToken_example # String |  (optional) (default to null)

try:
    api_response = api_instance.refresh_token(refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->refreshToken: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {
    let refreshToken = refreshToken_example; // String

    let mut context = LoginControllerApi::Context::default();
    let result = client.refreshToken(refreshToken, &context).wait();

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

Scopes

Parameters

Responses

Schema

status

/api/v1/auth/status

Usage and SDK Samples

curl -X GET \
 "http://localhost:8080/api/v1/auth/status"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.status();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->status: $e\n');
}

import org.openapitools.client.api.LoginControllerApi;

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

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



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

[apiInstance statusWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.status(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                apiInstance.status();
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.status: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $api_instance->status();
} catch (Exception $e) {
    echo 'Exception when calling LoginControllerApi->status: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

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

eval {
    $api_instance->status();
};
if ($@) {
    warn "Exception when calling LoginControllerApi->status: $@\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.LoginControllerApi()

try:
    api_instance.status()
except ApiException as e:
    print("Exception when calling LoginControllerApi->status: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {

    let mut context = LoginControllerApi::Context::default();
    let result = client.status(&context).wait();

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

Scopes

Parameters

Responses

MatchRestController

creatematch

/api/v1/matches

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/matches" \
 -d '{
  "date" : "2000-01-23T04:56:07.000+00:00",
  "modeSelected" : 6,
  "team2Players" : [ {
    "password" : "password",
    "gender" : true,
    "level" : 6.0274563,
    "stats" : {
      "wins" : 5,
      "draws" : 5,
      "winRate" : 7.061401241503109,
      "totalMatches" : 1,
      "losses" : 2
    },
    "roles" : [ "roles", "roles" ],
    "description" : "description",
    "id" : 0,
    "birthDate" : "2000-01-23T04:56:07.000+00:00",
    "email" : "email",
    "realname" : "realname",
    "username" : "username"
  }, {
    "password" : "password",
    "gender" : true,
    "level" : 6.0274563,
    "stats" : {
      "wins" : 5,
      "draws" : 5,
      "winRate" : 7.061401241503109,
      "totalMatches" : 1,
      "losses" : 2
    },
    "roles" : [ "roles", "roles" ],
    "description" : "description",
    "id" : 0,
    "birthDate" : "2000-01-23T04:56:07.000+00:00",
    "email" : "email",
    "realname" : "realname",
    "username" : "username"
  } ],
  "team1Players" : [ {
    "password" : "password",
    "gender" : true,
    "level" : 6.0274563,
    "stats" : {
      "wins" : 5,
      "draws" : 5,
      "winRate" : 7.061401241503109,
      "totalMatches" : 1,
      "losses" : 2
    },
    "roles" : [ "roles", "roles" ],
    "description" : "description",
    "id" : 0,
    "birthDate" : "2000-01-23T04:56:07.000+00:00",
    "email" : "email",
    "realname" : "realname",
    "username" : "username"
  }, {
    "password" : "password",
    "gender" : true,
    "level" : 6.0274563,
    "stats" : {
      "wins" : 5,
      "draws" : 5,
      "winRate" : 7.061401241503109,
      "totalMatches" : 1,
      "losses" : 2
    },
    "roles" : [ "roles", "roles" ],
    "description" : "description",
    "id" : 0,
    "birthDate" : "2000-01-23T04:56:07.000+00:00",
    "email" : "email",
    "realname" : "realname",
    "username" : "username"
  } ],
  "isPrivate" : true,
  "type" : true,
  "result" : {
    "team1Score" : 7,
    "team1Name" : "team1Name",
    "team1Sets" : 3,
    "team2Name" : "team2Name",
    "team2Sets" : 2,
    "team2Score" : 9,
    "team1GamesPerSet" : [ 4, 4 ],
    "team2GamesPerSet" : [ 7, 7 ]
  },
  "organizer" : {
    "level" : 5.962134,
    "id" : 1,
    "realname" : "realname",
    "username" : "username"
  },
  "price" : 5.637377,
  "club" : {
    "city" : "city",
    "name" : "name",
    "id" : 2
  },
  "id" : 0,
  "state" : true,
  "sport" : {
    "modes" : [ {
      "name" : "name",
      "playersPerGame" : 6
    }, {
      "name" : "name",
      "playersPerGame" : 6
    } ],
    "scoringType" : "SCORE",
    "name" : "name",
    "id" : 0
  }
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRestControllerApi;

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

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

        // Create an instance of the API class
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        MatchDTO matchDTO = ; // MatchDTO | 

        try {
            MatchDTO result = apiInstance.creatematch(matchDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#creatematch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MatchDTO matchDTO = new MatchDTO(); // MatchDTO | 

try {
    final result = await api_instance.creatematch(matchDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->creatematch: $e\n');
}

import org.openapitools.client.api.MatchRestControllerApi;

public class MatchRestControllerApiExample {
    public static void main(String[] args) {
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        MatchDTO matchDTO = ; // MatchDTO | 

        try {
            MatchDTO result = apiInstance.creatematch(matchDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#creatematch");
            e.printStackTrace();
        }
    }
}



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

[apiInstance creatematchWith:matchDTO
              completionHandler: ^(MatchDTO 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.MatchRestControllerApi()
var matchDTO = ; // {MatchDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.creatematch(matchDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new MatchRestControllerApi();
            var matchDTO = new MatchDTO(); // MatchDTO | 

            try {
                MatchDTO result = apiInstance.creatematch(matchDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.creatematch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MatchRestControllerApi();
$matchDTO = ; // MatchDTO | 

try {
    $result = $api_instance->creatematch($matchDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MatchRestControllerApi->creatematch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MatchRestControllerApi->new();
my $matchDTO = WWW::OPenAPIClient::Object::MatchDTO->new(); # MatchDTO | 

eval {
    my $result = $api_instance->creatematch(matchDTO => $matchDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchRestControllerApi->creatematch: $@\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.MatchRestControllerApi()
matchDTO =  # MatchDTO | 

try:
    api_response = api_instance.creatematch(matchDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->creatematch: %s\n" % e)

extern crate MatchRestControllerApi;

pub fn main() {
    let matchDTO = ; // MatchDTO

    let mut context = MatchRestControllerApi::Context::default();
    let result = client.creatematch(matchDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
matchDTO *

Responses

Schema

deleteMatch

/api/v1/matches/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/matches/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRestControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteMatch(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteMatch: $e\n');
}

import org.openapitools.client.api.MatchRestControllerApi;

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

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



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

[apiInstance deleteMatchWith:id
              completionHandler: ^(MatchDTO 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.MatchRestControllerApi()
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.deleteMatch(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                MatchDTO result = apiInstance.deleteMatch(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.deleteMatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->deleteMatch($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MatchRestControllerApi->deleteMatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRestControllerApi;

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

eval {
    my $result = $api_instance->deleteMatch(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchRestControllerApi->deleteMatch: $@\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.MatchRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.delete_match(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->deleteMatch: %s\n" % e)

extern crate MatchRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getFilteredMatches

/api/v1/matches

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/matches?page=56&size=56&search=search_example&sport=sport_example&includeFriendlies=true&timeRange=timeRange_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRestControllerApi;

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

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

        // Create an instance of the API class
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 
        String search = search_example; // String | 
        String sport = sport_example; // String | 
        Boolean includeFriendlies = true; // Boolean | 
        String timeRange = timeRange_example; // String | 

        try {
            PageMatchDTO result = apiInstance.getFilteredMatches(page, size, search, sport, includeFriendlies, timeRange);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#getFilteredMatches");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | 
final Integer size = new Integer(); // Integer | 
final String search = new String(); // String | 
final String sport = new String(); // String | 
final Boolean includeFriendlies = new Boolean(); // Boolean | 
final String timeRange = new String(); // String | 

try {
    final result = await api_instance.getFilteredMatches(page, size, search, sport, includeFriendlies, timeRange);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getFilteredMatches: $e\n');
}

import org.openapitools.client.api.MatchRestControllerApi;

public class MatchRestControllerApiExample {
    public static void main(String[] args) {
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 
        String search = search_example; // String | 
        String sport = sport_example; // String | 
        Boolean includeFriendlies = true; // Boolean | 
        String timeRange = timeRange_example; // String | 

        try {
            PageMatchDTO result = apiInstance.getFilteredMatches(page, size, search, sport, includeFriendlies, timeRange);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#getFilteredMatches");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
MatchRestControllerApi *apiInstance = [[MatchRestControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to 0)
Integer *size = 56; //  (optional) (default to 10)
String *search = search_example; //  (optional) (default to null)
String *sport = sport_example; //  (optional) (default to null)
Boolean *includeFriendlies = true; //  (optional) (default to null)
String *timeRange = timeRange_example; //  (optional) (default to null)

[apiInstance getFilteredMatchesWith:page
    size:size
    search:search
    sport:sport
    includeFriendlies:includeFriendlies
    timeRange:timeRange
              completionHandler: ^(PageMatchDTO 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.MatchRestControllerApi()
var opts = {
  'page': 56, // {Integer} 
  'size': 56, // {Integer} 
  'search': search_example, // {String} 
  'sport': sport_example, // {String} 
  'includeFriendlies': true, // {Boolean} 
  'timeRange': timeRange_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getFilteredMatches(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new MatchRestControllerApi();
            var page = 56;  // Integer |  (optional)  (default to 0)
            var size = 56;  // Integer |  (optional)  (default to 10)
            var search = search_example;  // String |  (optional)  (default to null)
            var sport = sport_example;  // String |  (optional)  (default to null)
            var includeFriendlies = true;  // Boolean |  (optional)  (default to null)
            var timeRange = timeRange_example;  // String |  (optional)  (default to null)

            try {
                PageMatchDTO result = apiInstance.getFilteredMatches(page, size, search, sport, includeFriendlies, timeRange);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.getFilteredMatches: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MatchRestControllerApi();
$page = 56; // Integer | 
$size = 56; // Integer | 
$search = search_example; // String | 
$sport = sport_example; // String | 
$includeFriendlies = true; // Boolean | 
$timeRange = timeRange_example; // String | 

try {
    $result = $api_instance->getFilteredMatches($page, $size, $search, $sport, $includeFriendlies, $timeRange);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MatchRestControllerApi->getFilteredMatches: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MatchRestControllerApi->new();
my $page = 56; # Integer | 
my $size = 56; # Integer | 
my $search = search_example; # String | 
my $sport = sport_example; # String | 
my $includeFriendlies = true; # Boolean | 
my $timeRange = timeRange_example; # String | 

eval {
    my $result = $api_instance->getFilteredMatches(page => $page, size => $size, search => $search, sport => $sport, includeFriendlies => $includeFriendlies, timeRange => $timeRange);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchRestControllerApi->getFilteredMatches: $@\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.MatchRestControllerApi()
page = 56 # Integer |  (optional) (default to 0)
size = 56 # Integer |  (optional) (default to 10)
search = search_example # String |  (optional) (default to null)
sport = sport_example # String |  (optional) (default to null)
includeFriendlies = true # Boolean |  (optional) (default to null)
timeRange = timeRange_example # String |  (optional) (default to null)

try:
    api_response = api_instance.get_filtered_matches(page=page, size=size, search=search, sport=sport, includeFriendlies=includeFriendlies, timeRange=timeRange)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->getFilteredMatches: %s\n" % e)

extern crate MatchRestControllerApi;

pub fn main() {
    let page = 56; // Integer
    let size = 56; // Integer
    let search = search_example; // String
    let sport = sport_example; // String
    let includeFriendlies = true; // Boolean
    let timeRange = timeRange_example; // String

    let mut context = MatchRestControllerApi::Context::default();
    let result = client.getFilteredMatches(page, size, search, sport, includeFriendlies, timeRange, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
page	Integer (int32)
size	Integer (int32)
search	String
sport	String
includeFriendlies	Boolean
timeRange	String

Responses

Schema

getMatch

/api/v1/matches/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/matches/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRestControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getMatch(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getMatch: $e\n');
}

import org.openapitools.client.api.MatchRestControllerApi;

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

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



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

[apiInstance getMatchWith:id
              completionHandler: ^(MatchDTO 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.MatchRestControllerApi()
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.getMatch(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                MatchDTO result = apiInstance.getMatch(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.getMatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getMatch($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MatchRestControllerApi->getMatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRestControllerApi;

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

eval {
    my $result = $api_instance->getMatch(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchRestControllerApi->getMatch: $@\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.MatchRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_match(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->getMatch: %s\n" % e)

extern crate MatchRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getMatches

/api/v1/matches/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/matches/?pageable="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRestControllerApi;

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

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

        // Create an instance of the API class
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageMatchDTO result = apiInstance.getMatches(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#getMatches");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 

try {
    final result = await api_instance.getMatches(pageable);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getMatches: $e\n');
}

import org.openapitools.client.api.MatchRestControllerApi;

public class MatchRestControllerApiExample {
    public static void main(String[] args) {
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PageMatchDTO result = apiInstance.getMatches(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#getMatches");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
MatchRestControllerApi *apiInstance = [[MatchRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

[apiInstance getMatchesWith:pageable
              completionHandler: ^(PageMatchDTO 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.MatchRestControllerApi()
var pageable = ; // {Pageable} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMatches(pageable, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new MatchRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                PageMatchDTO result = apiInstance.getMatches(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.getMatches: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MatchRestControllerApi();
$pageable = ; // Pageable | 

try {
    $result = $api_instance->getMatches($pageable);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MatchRestControllerApi->getMatches: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRestControllerApi;

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

eval {
    my $result = $api_instance->getMatches(pageable => $pageable);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchRestControllerApi->getMatches: $@\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.MatchRestControllerApi()
pageable =  # Pageable |  (default to null)

try:
    api_response = api_instance.get_matches(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->getMatches: %s\n" % e)

extern crate MatchRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable

    let mut context = MatchRestControllerApi::Context::default();
    let result = client.getMatches(pageable, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

joinMatch

/api/v1/matches/{id}/users/me

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/matches/{id}/users/me" \
 -d '{
  "team" : "team"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRestControllerApi;

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

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

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

        try {
            map['String', 'String'] result = apiInstance.joinMatch(id, joinMatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#joinMatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final JoinMatchRequest joinMatchRequest = new JoinMatchRequest(); // JoinMatchRequest | 

try {
    final result = await api_instance.joinMatch(id, joinMatchRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->joinMatch: $e\n');
}

import org.openapitools.client.api.MatchRestControllerApi;

public class MatchRestControllerApiExample {
    public static void main(String[] args) {
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        Long id = 789; // Long | 
        JoinMatchRequest joinMatchRequest = ; // JoinMatchRequest | 

        try {
            map['String', 'String'] result = apiInstance.joinMatch(id, joinMatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#joinMatch");
            e.printStackTrace();
        }
    }
}



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

[apiInstance joinMatchWith:id
    joinMatchRequest:joinMatchRequest
              completionHandler: ^(map['String', '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.MatchRestControllerApi()
var id = 789; // {Long} 
var joinMatchRequest = ; // {JoinMatchRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.joinMatch(id, joinMatchRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                map['String', 'String'] result = apiInstance.joinMatch(id, joinMatchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.joinMatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->joinMatch($id, $joinMatchRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MatchRestControllerApi->joinMatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRestControllerApi;

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

eval {
    my $result = $api_instance->joinMatch(id => $id, joinMatchRequest => $joinMatchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchRestControllerApi->joinMatch: $@\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.MatchRestControllerApi()
id = 789 # Long |  (default to null)
joinMatchRequest =  # JoinMatchRequest | 

try:
    api_response = api_instance.join_match(id, joinMatchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->joinMatch: %s\n" % e)

extern crate MatchRestControllerApi;

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

    let mut context = MatchRestControllerApi::Context::default();
    let result = client.joinMatch(id, joinMatchRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
joinMatchRequest *

Responses

Schema

leaveMatch

/api/v1/matches/{id}/users/me

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/matches/{id}/users/me"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRestControllerApi;

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

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

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

        try {
            map['String', 'String'] result = apiInstance.leaveMatch(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#leaveMatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.leaveMatch(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->leaveMatch: $e\n');
}

import org.openapitools.client.api.MatchRestControllerApi;

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

        try {
            map['String', 'String'] result = apiInstance.leaveMatch(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#leaveMatch");
            e.printStackTrace();
        }
    }
}



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

[apiInstance leaveMatchWith:id
              completionHandler: ^(map['String', '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.MatchRestControllerApi()
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.leaveMatch(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                map['String', 'String'] result = apiInstance.leaveMatch(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.leaveMatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->leaveMatch($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MatchRestControllerApi->leaveMatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRestControllerApi;

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

eval {
    my $result = $api_instance->leaveMatch(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchRestControllerApi->leaveMatch: $@\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.MatchRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.leave_match(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->leaveMatch: %s\n" % e)

extern crate MatchRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

replaceMatch

/api/v1/matches/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/matches/{id}" \
 -d '{
  "date" : "2000-01-23T04:56:07.000+00:00",
  "modeSelected" : 6,
  "team2Players" : [ {
    "password" : "password",
    "gender" : true,
    "level" : 6.0274563,
    "stats" : {
      "wins" : 5,
      "draws" : 5,
      "winRate" : 7.061401241503109,
      "totalMatches" : 1,
      "losses" : 2
    },
    "roles" : [ "roles", "roles" ],
    "description" : "description",
    "id" : 0,
    "birthDate" : "2000-01-23T04:56:07.000+00:00",
    "email" : "email",
    "realname" : "realname",
    "username" : "username"
  }, {
    "password" : "password",
    "gender" : true,
    "level" : 6.0274563,
    "stats" : {
      "wins" : 5,
      "draws" : 5,
      "winRate" : 7.061401241503109,
      "totalMatches" : 1,
      "losses" : 2
    },
    "roles" : [ "roles", "roles" ],
    "description" : "description",
    "id" : 0,
    "birthDate" : "2000-01-23T04:56:07.000+00:00",
    "email" : "email",
    "realname" : "realname",
    "username" : "username"
  } ],
  "team1Players" : [ {
    "password" : "password",
    "gender" : true,
    "level" : 6.0274563,
    "stats" : {
      "wins" : 5,
      "draws" : 5,
      "winRate" : 7.061401241503109,
      "totalMatches" : 1,
      "losses" : 2
    },
    "roles" : [ "roles", "roles" ],
    "description" : "description",
    "id" : 0,
    "birthDate" : "2000-01-23T04:56:07.000+00:00",
    "email" : "email",
    "realname" : "realname",
    "username" : "username"
  }, {
    "password" : "password",
    "gender" : true,
    "level" : 6.0274563,
    "stats" : {
      "wins" : 5,
      "draws" : 5,
      "winRate" : 7.061401241503109,
      "totalMatches" : 1,
      "losses" : 2
    },
    "roles" : [ "roles", "roles" ],
    "description" : "description",
    "id" : 0,
    "birthDate" : "2000-01-23T04:56:07.000+00:00",
    "email" : "email",
    "realname" : "realname",
    "username" : "username"
  } ],
  "isPrivate" : true,
  "type" : true,
  "result" : {
    "team1Score" : 7,
    "team1Name" : "team1Name",
    "team1Sets" : 3,
    "team2Name" : "team2Name",
    "team2Sets" : 2,
    "team2Score" : 9,
    "team1GamesPerSet" : [ 4, 4 ],
    "team2GamesPerSet" : [ 7, 7 ]
  },
  "organizer" : {
    "level" : 5.962134,
    "id" : 1,
    "realname" : "realname",
    "username" : "username"
  },
  "price" : 5.637377,
  "club" : {
    "city" : "city",
    "name" : "name",
    "id" : 2
  },
  "id" : 0,
  "state" : true,
  "sport" : {
    "modes" : [ {
      "name" : "name",
      "playersPerGame" : 6
    }, {
      "name" : "name",
      "playersPerGame" : 6
    } ],
    "scoringType" : "SCORE",
    "name" : "name",
    "id" : 0
  }
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.MatchRestControllerApi;

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

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

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

        try {
            MatchDTO result = apiInstance.replaceMatch(id, matchDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#replaceMatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final MatchDTO matchDTO = new MatchDTO(); // MatchDTO | 

try {
    final result = await api_instance.replaceMatch(id, matchDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceMatch: $e\n');
}

import org.openapitools.client.api.MatchRestControllerApi;

public class MatchRestControllerApiExample {
    public static void main(String[] args) {
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        Long id = 789; // Long | 
        MatchDTO matchDTO = ; // MatchDTO | 

        try {
            MatchDTO result = apiInstance.replaceMatch(id, matchDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#replaceMatch");
            e.printStackTrace();
        }
    }
}



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

[apiInstance replaceMatchWith:id
    matchDTO:matchDTO
              completionHandler: ^(MatchDTO 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.MatchRestControllerApi()
var id = 789; // {Long} 
var matchDTO = ; // {MatchDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceMatch(id, matchDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                MatchDTO result = apiInstance.replaceMatch(id, matchDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.replaceMatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->replaceMatch($id, $matchDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling MatchRestControllerApi->replaceMatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::MatchRestControllerApi;

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

eval {
    my $result = $api_instance->replaceMatch(id => $id, matchDTO => $matchDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchRestControllerApi->replaceMatch: $@\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.MatchRestControllerApi()
id = 789 # Long |  (default to null)
matchDTO =  # MatchDTO | 

try:
    api_response = api_instance.replace_match(id, matchDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->replaceMatch: %s\n" % e)

extern crate MatchRestControllerApi;

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

    let mut context = MatchRestControllerApi::Context::default();
    let result = client.replaceMatch(id, matchDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
matchDTO *

Responses

Schema

SportRestController

createSport

/api/v1/sports/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/sports/" \
 -d '{
  "modes" : [ {
    "name" : "name",
    "playersPerGame" : 6
  }, {
    "name" : "name",
    "playersPerGame" : 6
  } ],
  "scoringType" : "SCORE",
  "name" : "name",
  "id" : 0
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SportRestControllerApi;

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

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

        // Create an instance of the API class
        SportRestControllerApi apiInstance = new SportRestControllerApi();
        SportDTO sportDTO = ; // SportDTO | 

        try {
            SportDTO result = apiInstance.createSport(sportDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SportRestControllerApi#createSport");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SportDTO sportDTO = new SportDTO(); // SportDTO | 

try {
    final result = await api_instance.createSport(sportDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createSport: $e\n');
}

import org.openapitools.client.api.SportRestControllerApi;

public class SportRestControllerApiExample {
    public static void main(String[] args) {
        SportRestControllerApi apiInstance = new SportRestControllerApi();
        SportDTO sportDTO = ; // SportDTO | 

        try {
            SportDTO result = apiInstance.createSport(sportDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SportRestControllerApi#createSport");
            e.printStackTrace();
        }
    }
}



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

[apiInstance createSportWith:sportDTO
              completionHandler: ^(SportDTO 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.SportRestControllerApi()
var sportDTO = ; // {SportDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createSport(sportDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new SportRestControllerApi();
            var sportDTO = new SportDTO(); // SportDTO | 

            try {
                SportDTO result = apiInstance.createSport(sportDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SportRestControllerApi.createSport: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SportRestControllerApi();
$sportDTO = ; // SportDTO | 

try {
    $result = $api_instance->createSport($sportDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SportRestControllerApi->createSport: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SportRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SportRestControllerApi->new();
my $sportDTO = WWW::OPenAPIClient::Object::SportDTO->new(); # SportDTO | 

eval {
    my $result = $api_instance->createSport(sportDTO => $sportDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SportRestControllerApi->createSport: $@\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.SportRestControllerApi()
sportDTO =  # SportDTO | 

try:
    api_response = api_instance.create_sport(sportDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SportRestControllerApi->createSport: %s\n" % e)

extern crate SportRestControllerApi;

pub fn main() {
    let sportDTO = ; // SportDTO

    let mut context = SportRestControllerApi::Context::default();
    let result = client.createSport(sportDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
sportDTO *

Responses

Schema

deleteSport

/api/v1/sports/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/sports/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SportRestControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteSport(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteSport: $e\n');
}

import org.openapitools.client.api.SportRestControllerApi;

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

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



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

[apiInstance deleteSportWith:id
              completionHandler: ^(SportDTO 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.SportRestControllerApi()
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.deleteSport(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                SportDTO result = apiInstance.deleteSport(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SportRestControllerApi.deleteSport: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->deleteSport($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SportRestControllerApi->deleteSport: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SportRestControllerApi;

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

eval {
    my $result = $api_instance->deleteSport(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SportRestControllerApi->deleteSport: $@\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.SportRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.delete_sport(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SportRestControllerApi->deleteSport: %s\n" % e)

extern crate SportRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getSport

/api/v1/sports/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/sports/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SportRestControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getSport(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSport: $e\n');
}

import org.openapitools.client.api.SportRestControllerApi;

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

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



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

[apiInstance getSportWith:id
              completionHandler: ^(SportDTO 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.SportRestControllerApi()
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.getSport(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                SportDTO result = apiInstance.getSport(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SportRestControllerApi.getSport: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getSport($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SportRestControllerApi->getSport: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SportRestControllerApi;

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

eval {
    my $result = $api_instance->getSport(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SportRestControllerApi->getSport: $@\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.SportRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_sport(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SportRestControllerApi->getSport: %s\n" % e)

extern crate SportRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getSports

/api/v1/sports/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/sports/"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SportRestControllerApi;

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

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

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

        try {
            array[SportDTO] result = apiInstance.getSports();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SportRestControllerApi#getSports");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getSports();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getSports: $e\n');
}

import org.openapitools.client.api.SportRestControllerApi;

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

        try {
            array[SportDTO] result = apiInstance.getSports();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SportRestControllerApi#getSports");
            e.printStackTrace();
        }
    }
}



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

[apiInstance getSportsWithCompletionHandler: 
              ^(array[SportDTO] 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.SportRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getSports(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[SportDTO] result = apiInstance.getSports();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SportRestControllerApi.getSports: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getSports();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SportRestControllerApi->getSports: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SportRestControllerApi;

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

eval {
    my $result = $api_instance->getSports();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SportRestControllerApi->getSports: $@\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.SportRestControllerApi()

try:
    api_response = api_instance.get_sports()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SportRestControllerApi->getSports: %s\n" % e)

extern crate SportRestControllerApi;

pub fn main() {

    let mut context = SportRestControllerApi::Context::default();
    let result = client.getSports(&context).wait();

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

Scopes

Parameters

Responses

Schema

replaceSport

/api/v1/sports/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/sports/{id}" \
 -d '{
  "modes" : [ {
    "name" : "name",
    "playersPerGame" : 6
  }, {
    "name" : "name",
    "playersPerGame" : 6
  } ],
  "scoringType" : "SCORE",
  "name" : "name",
  "id" : 0
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SportRestControllerApi;

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

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

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

        try {
            SportDTO result = apiInstance.replaceSport(id, sportDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SportRestControllerApi#replaceSport");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final SportDTO sportDTO = new SportDTO(); // SportDTO | 

try {
    final result = await api_instance.replaceSport(id, sportDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceSport: $e\n');
}

import org.openapitools.client.api.SportRestControllerApi;

public class SportRestControllerApiExample {
    public static void main(String[] args) {
        SportRestControllerApi apiInstance = new SportRestControllerApi();
        Long id = 789; // Long | 
        SportDTO sportDTO = ; // SportDTO | 

        try {
            SportDTO result = apiInstance.replaceSport(id, sportDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SportRestControllerApi#replaceSport");
            e.printStackTrace();
        }
    }
}



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

[apiInstance replaceSportWith:id
    sportDTO:sportDTO
              completionHandler: ^(SportDTO 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.SportRestControllerApi()
var id = 789; // {Long} 
var sportDTO = ; // {SportDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceSport(id, sportDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                SportDTO result = apiInstance.replaceSport(id, sportDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling SportRestControllerApi.replaceSport: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->replaceSport($id, $sportDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SportRestControllerApi->replaceSport: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::SportRestControllerApi;

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

eval {
    my $result = $api_instance->replaceSport(id => $id, sportDTO => $sportDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SportRestControllerApi->replaceSport: $@\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.SportRestControllerApi()
id = 789 # Long |  (default to null)
sportDTO =  # SportDTO | 

try:
    api_response = api_instance.replace_sport(id, sportDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SportRestControllerApi->replaceSport: %s\n" % e)

extern crate SportRestControllerApi;

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

    let mut context = SportRestControllerApi::Context::default();
    let result = client.replaceSport(id, sportDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
sportDTO *

Responses

Schema

UserRestController

createUser

/api/v1/users/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/users/" \
 -d '{
  "password" : "password",
  "gender" : true,
  "level" : 6.0274563,
  "stats" : {
    "wins" : 5,
    "draws" : 5,
    "winRate" : 7.061401241503109,
    "totalMatches" : 1,
    "losses" : 2
  },
  "roles" : [ "roles", "roles" ],
  "description" : "description",
  "id" : 0,
  "birthDate" : "2000-01-23T04:56:07.000+00:00",
  "email" : "email",
  "realname" : "realname",
  "username" : "username"
}'

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();
        UserDTO userDTO = ; // UserDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserDTO userDTO = new UserDTO(); // UserDTO | 

try {
    final result = await api_instance.createUser(userDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

[apiInstance createUserWith:userDTO
              completionHandler: ^(UserDTO 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 userDTO = ; // {UserDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createUser(userDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                UserDTO result = apiInstance.createUser(userDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.createUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->createUser($userDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->createUser: ', $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 $userDTO = WWW::OPenAPIClient::Object::UserDTO->new(); # UserDTO | 

eval {
    my $result = $api_instance->createUser(userDTO => $userDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->createUser: $@\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()
userDTO =  # UserDTO | 

try:
    api_response = api_instance.create_user(userDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->createUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let userDTO = ; // UserDTO

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

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

Scopes

Parameters

Body parameters

Name	Description
userDTO *

Responses

Schema

createUserImage

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/users/{id}/image" \
 -d ''

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 | 
        PutUserImageRequest putUserImageRequest = ; // PutUserImageRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final PutUserImageRequest putUserImageRequest = new PutUserImageRequest(); // PutUserImageRequest | 

try {
    final result = await api_instance.createUserImage(id, putUserImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createUserImage: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

[apiInstance createUserImageWith:id
    putUserImageRequest:putUserImageRequest
              completionHandler: ^(Object 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} 
var opts = {
  'putUserImageRequest':  // {PutUserImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createUserImage(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.createUserImage(id, putUserImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.createUserImage: " + 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 | 
$putUserImageRequest = ; // PutUserImageRequest | 

try {
    $result = $api_instance->createUserImage($id, $putUserImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->createUserImage: ', $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 | 
my $putUserImageRequest = WWW::OPenAPIClient::Object::PutUserImageRequest->new(); # PutUserImageRequest | 

eval {
    my $result = $api_instance->createUserImage(id => $id, putUserImageRequest => $putUserImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->createUserImage: $@\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 |  (default to null)
putUserImageRequest =  # PutUserImageRequest |  (optional)

try:
    api_response = api_instance.create_user_image(id, putUserImageRequest=putUserImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->createUserImage: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
putUserImageRequest

Responses

Schema

deleteUser

/api/v1/users/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/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 | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteUser(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

[apiInstance deleteUserWith:id
              completionHandler: ^(UserDTO 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} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteUser(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                UserDTO result = apiInstance.deleteUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteUser: " + 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 | 

try {
    $result = $api_instance->deleteUser($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->deleteUser: ', $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 | 

eval {
    my $result = $api_instance->deleteUser(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->deleteUser: $@\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 |  (default to null)

try:
    api_response = api_instance.delete_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteUser: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUser

/api/v1/users/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/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 | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getUser(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

        try {
            UserDTO 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; //  (default to null)

[apiInstance getUserWith:id
              completionHandler: ^(UserDTO 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} 

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 |  (default to null)

            try {
                UserDTO 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 | 

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 | 

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 |  (default to null)

try:
    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) Required

Responses

Schema

getUserImage

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/users/{id}/image"

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 | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getUserImage(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUserImage: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

[apiInstance getUserImageWith:id
              completionHandler: ^(Object 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} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserImage(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.getUserImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserImage: " + 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 | 

try {
    $result = $api_instance->getUserImage($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUserImage: ', $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 | 

eval {
    my $result = $api_instance->getUserImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUserImage: $@\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 |  (default to null)

try:
    api_response = api_instance.get_user_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserImage: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUserMatches

/api/v1/users/{id}/matches/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/users/{id}/matches/"

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 | 

        try {
            array[MatchDTO] result = apiInstance.getUserMatches(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUserMatches");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getUserMatches(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUserMatches: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

        try {
            array[MatchDTO] result = apiInstance.getUserMatches(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUserMatches");
            e.printStackTrace();
        }
    }
}



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

[apiInstance getUserMatchesWith:id
              completionHandler: ^(array[MatchDTO] 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} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUserMatches(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                array[MatchDTO] result = apiInstance.getUserMatches(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserMatches: " + 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 | 

try {
    $result = $api_instance->getUserMatches($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUserMatches: ', $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 | 

eval {
    my $result = $api_instance->getUserMatches(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUserMatches: $@\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 |  (default to null)

try:
    api_response = api_instance.get_user_matches(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserMatches: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUsers

/api/v1/users/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/users/?pageable="

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();
        Pageable pageable = ; // Pageable | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 

try {
    final result = await api_instance.getUsers(pageable);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUsers: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

[apiInstance getUsersWith:pageable
              completionHandler: ^(PageUserDTO 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 pageable = ; // {Pageable} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsers(pageable, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                PageUserDTO result = apiInstance.getUsers(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUsers: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getUsers($pageable);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUsers: ', $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 $pageable = ; # Pageable | 

eval {
    my $result = $api_instance->getUsers(pageable => $pageable);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUsers: $@\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()
pageable =  # Pageable |  (default to null)

try:
    api_response = api_instance.get_users(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUsers: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

me

/api/v1/users/me

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://localhost:8080/api/v1/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 {
            UserDTO result = apiInstance.me();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#me");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.me();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->me: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

[apiInstance meWithCompletionHandler: 
              ^(UserDTO 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.me(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                UserDTO result = apiInstance.me();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.me: " + 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->me();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->me: ', $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->me();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->me: $@\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:
    api_response = api_instance.me()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->me: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

putUserImage

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/users/{id}/image" \
 -d ''

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 | 
        PutUserImageRequest putUserImageRequest = ; // PutUserImageRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final PutUserImageRequest putUserImageRequest = new PutUserImageRequest(); // PutUserImageRequest | 

try {
    final result = await api_instance.putUserImage(id, putUserImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putUserImage: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

[apiInstance putUserImageWith:id
    putUserImageRequest:putUserImageRequest
              completionHandler: ^(Object 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} 
var opts = {
  'putUserImageRequest':  // {PutUserImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.putUserImage(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.putUserImage(id, putUserImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.putUserImage: " + 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 | 
$putUserImageRequest = ; // PutUserImageRequest | 

try {
    $result = $api_instance->putUserImage($id, $putUserImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->putUserImage: ', $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 | 
my $putUserImageRequest = WWW::OPenAPIClient::Object::PutUserImageRequest->new(); # PutUserImageRequest | 

eval {
    my $result = $api_instance->putUserImage(id => $id, putUserImageRequest => $putUserImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->putUserImage: $@\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 |  (default to null)
putUserImageRequest =  # PutUserImageRequest |  (optional)

try:
    api_response = api_instance.put_user_image(id, putUserImageRequest=putUserImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->putUserImage: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
putUserImageRequest

Responses

Schema

replaceUser

/api/v1/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://localhost:8080/api/v1/users/{id}" \
 -d '{
  "password" : "password",
  "gender" : true,
  "level" : 6.0274563,
  "stats" : {
    "wins" : 5,
    "draws" : 5,
    "winRate" : 7.061401241503109,
    "totalMatches" : 1,
    "losses" : 2
  },
  "roles" : [ "roles", "roles" ],
  "description" : "description",
  "id" : 0,
  "birthDate" : "2000-01-23T04:56:07.000+00:00",
  "email" : "email",
  "realname" : "realname",
  "username" : "username"
}'

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 | 
        UserDTO userDTO = ; // UserDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UserDTO userDTO = new UserDTO(); // UserDTO | 

try {
    final result = await api_instance.replaceUser(id, userDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

[apiInstance replaceUserWith:id
    userDTO:userDTO
              completionHandler: ^(UserDTO 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} 
var userDTO = ; // {UserDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceUser(id, userDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                UserDTO result = apiInstance.replaceUser(id, userDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.replaceUser: " + 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 | 
$userDTO = ; // UserDTO | 

try {
    $result = $api_instance->replaceUser($id, $userDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->replaceUser: ', $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 | 
my $userDTO = WWW::OPenAPIClient::Object::UserDTO->new(); # UserDTO | 

eval {
    my $result = $api_instance->replaceUser(id => $id, userDTO => $userDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->replaceUser: $@\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 |  (default to null)
userDTO =  # UserDTO | 

try:
    api_response = api_instance.replace_user(id, userDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->replaceUser: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
userDTO *

Responses

Schema

OpenAPI definition

API and SDK Documentation

ClubRestController

createClub

Usage and SDK Samples

Scopes

Parameters

Responses

createClubImage

Usage and SDK Samples

Scopes

Parameters

Responses

deleteClub

Usage and SDK Samples

Scopes

Parameters

Responses

getClub

Usage and SDK Samples

Scopes

Parameters

Responses

getClubImage

Usage and SDK Samples

Scopes

Parameters

Responses

getClubs

Usage and SDK Samples

Scopes

Parameters

Responses

getFilteredClubs

Usage and SDK Samples

Scopes

Parameters

Responses

putclubImage

Usage and SDK Samples

Scopes

Parameters

Responses

replaceClub

Usage and SDK Samples

Scopes

Parameters

Responses

LoginController

logOut

Usage and SDK Samples

Scopes

Parameters

Responses

login

Usage and SDK Samples

Scopes

Parameters

Responses

refreshToken

Usage and SDK Samples

Scopes

Parameters

Responses

status

Usage and SDK Samples

Scopes

Parameters

Responses

MatchRestController

creatematch

Usage and SDK Samples

Scopes

Parameters

Responses

deleteMatch

Usage and SDK Samples

Scopes

Parameters

Responses