# RoboCupMS - User API

## API and SDK Documentation

Version: 2.0.0

API slouží pro správů uživatelů na serveru. Umožnuje zakladní operace (informace o uživateli, vyhledavání, modifikace, odstranění). Uživatel může mít tyto role [ADMIN, LEADER, ASSISTANT, REFEREE, COMPETITOR].

# Default

# addPost

Přidá nového uživatele do databáze

Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER]

    /add

### Usage and SDK Samples

    curl -X POST \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/add" \
     -d ''

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            InlineObject inlineObject = ; // InlineObject |

            try {
                inline_response_200_2 result = apiInstance.addPost(inlineObject);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#addPost");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            InlineObject inlineObject = ; // InlineObject |

            try {
                inline_response_200_2 result = apiInstance.addPost(inlineObject);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#addPost");
                e.printStackTrace();
            }
        }
    }

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

    // Přidá nového uživatele do databáze
    [apiInstance addPostWith:inlineObject
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var inlineObject = ; // {InlineObject}

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var inlineObject = new InlineObject(); // InlineObject |

                try {
                    // Přidá nového uživatele do databáze
                    inline_response_200_2 result = apiInstance.addPost(inlineObject);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.addPost: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $inlineObject = ; // InlineObject |

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $inlineObject = WWW::OPenAPIClient::Object::InlineObject->new(); # InlineObject |

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

    try:
        # Přidá nového uživatele do databáze
        api_response = api_instance.add_post(inlineObject)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->addPost: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let inlineObject = ; // InlineObject

        let mut context = DefaultApi::Context::default();
        let result = client.addPost(inlineObject, &context).wait();

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

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
inlineObject * |

## Responses

###

# addRolePut

Přiřadí uživateli roli

Mají přístup jen uživatelé s touto rolí [ADMIN]

    /addRole

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/addRole?role=role_example&id=56"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String role = role_example; // String | Uživateska role, která bude uživateli přidělena
            Integer id = 56; // Integer | ID uživatele

            try {
                inline_response_200_2 result = apiInstance.addRolePut(role, id);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#addRolePut");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String role = role_example; // String | Uživateska role, která bude uživateli přidělena
            Integer id = 56; // Integer | ID uživatele

            try {
                inline_response_200_2 result = apiInstance.addRolePut(role, id);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#addRolePut");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *role = role_example; // Uživateska role, která bude uživateli přidělena (default to null)
    Integer *id = 56; // ID uživatele (default to null)

    // Přiřadí uživateli roli
    [apiInstance addRolePutWith:role
        id:id
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var role = role_example; // {String} Uživateska role, která bude uživateli přidělena
    var id = 56; // {Integer} ID uživatele

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var role = role_example;  // String | Uživateska role, která bude uživateli přidělena (default to null)
                var id = 56;  // Integer | ID uživatele (default to null)

                try {
                    // Přiřadí uživateli roli
                    inline_response_200_2 result = apiInstance.addRolePut(role, id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.addRolePut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $role = role_example; // String | Uživateska role, která bude uživateli přidělena
    $id = 56; // Integer | ID uživatele

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $role = role_example; # String | Uživateska role, která bude uživateli přidělena
    my $id = 56; # Integer | ID uživatele

    eval {
        my $result = $api_instance->addRolePut(role => $role, id => $id);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->addRolePut: $@\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.DefaultApi()
    role = role_example # String | Uživateska role, která bude uživateli přidělena (default to null)
    id = 56 # Integer | ID uživatele (default to null)

    try:
        # Přiřadí uživateli roli
        api_response = api_instance.add_role_put(role, id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->addRolePut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let role = role_example; // String
        let id = 56; // Integer

        let mut context = DefaultApi::Context::default();
        let result = client.addRolePut(role, id, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
role* | String Uživateska role, která bude uživateli přidělena Required
id* | Integer ID uživatele Required

## Responses

###

# allGet

Navrátí všechny dostupné informace o všech uživatelích

Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER, ASSISTANT]

    /all

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/all"

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

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

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

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

            try {
                inline_response_200_1 result = apiInstance.allGet();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#allGet");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

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

            try {
                inline_response_200_1 result = apiInstance.allGet();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#allGet");
                e.printStackTrace();
            }
        }
    }

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

    // Navrátí všechny dostupné informace o všech uživatelích
    [apiInstance allGetWithCompletionHandler:
                  ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.allGet(callback);

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

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

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

                try {
                    // Navrátí všechny dostupné informace o všech uživatelích
                    inline_response_200_1 result = apiInstance.allGet();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.allGet: " + e.Message );
                }
            }
        }
    }

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

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

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

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

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

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

    try:
        # Navrátí všechny dostupné informace o všech uživatelích
        api_response = api_instance.all_get()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->allGet: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.allGet(&context).wait();

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

## Scopes

## Parameters

## Responses

###

# changePasswordPut

Změna uživatelského hesla

    /changePassword

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/changePassword?currentPassword=currentPassword_example&newPassword=newPassword_example"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String currentPassword = currentPassword_example; // String | Aktuální uživatelské heslo
            String newPassword = newPassword_example; // String | Nové uživatelské heslo

            try {
                inline_response_200_2 result = apiInstance.changePasswordPut(currentPassword, newPassword);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#changePasswordPut");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String currentPassword = currentPassword_example; // String | Aktuální uživatelské heslo
            String newPassword = newPassword_example; // String | Nové uživatelské heslo

            try {
                inline_response_200_2 result = apiInstance.changePasswordPut(currentPassword, newPassword);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#changePasswordPut");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *currentPassword = currentPassword_example; // Aktuální uživatelské heslo (default to null)
    String *newPassword = newPassword_example; // Nové uživatelské heslo (default to null)

    // Změna uživatelského hesla
    [apiInstance changePasswordPutWith:currentPassword
        newPassword:newPassword
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var currentPassword = currentPassword_example; // {String} Aktuální uživatelské heslo
    var newPassword = newPassword_example; // {String} Nové uživatelské heslo

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var currentPassword = currentPassword_example;  // String | Aktuální uživatelské heslo (default to null)
                var newPassword = newPassword_example;  // String | Nové uživatelské heslo (default to null)

                try {
                    // Změna uživatelského hesla
                    inline_response_200_2 result = apiInstance.changePasswordPut(currentPassword, newPassword);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.changePasswordPut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $currentPassword = currentPassword_example; // String | Aktuální uživatelské heslo
    $newPassword = newPassword_example; // String | Nové uživatelské heslo

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $currentPassword = currentPassword_example; # String | Aktuální uživatelské heslo
    my $newPassword = newPassword_example; # String | Nové uživatelské heslo

    eval {
        my $result = $api_instance->changePasswordPut(currentPassword => $currentPassword, newPassword => $newPassword);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->changePasswordPut: $@\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.DefaultApi()
    currentPassword = currentPassword_example # String | Aktuální uživatelské heslo (default to null)
    newPassword = newPassword_example # String | Nové uživatelské heslo (default to null)

    try:
        # Změna uživatelského hesla
        api_response = api_instance.change_password_put(currentPassword, newPassword)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->changePasswordPut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let currentPassword = currentPassword_example; // String
        let newPassword = newPassword_example; // String

        let mut context = DefaultApi::Context::default();
        let result = client.changePasswordPut(currentPassword, newPassword, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
currentPassword* | String Aktuální uživatelské heslo Required
newPassword* | String Nové uživatelské heslo Required

## Responses

###

# editPut

Umožní editovat údaje přihlášeného uživatele

    /edit

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     -H "Content-Type: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/edit" \
     -d ''

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            InlineObject1 inlineObject1 = ; // InlineObject1 |

            try {
                inline_response_200_2 result = apiInstance.editPut(inlineObject1);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#editPut");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            InlineObject1 inlineObject1 = ; // InlineObject1 |

            try {
                inline_response_200_2 result = apiInstance.editPut(inlineObject1);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#editPut");
                e.printStackTrace();
            }
        }
    }

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

    // Umožní editovat údaje přihlášeného uživatele
    [apiInstance editPutWith:inlineObject1
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var inlineObject1 = ; // {InlineObject1}

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var inlineObject1 = new InlineObject1(); // InlineObject1 |

                try {
                    // Umožní editovat údaje přihlášeného uživatele
                    inline_response_200_2 result = apiInstance.editPut(inlineObject1);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.editPut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $inlineObject1 = ; // InlineObject1 |

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $inlineObject1 = WWW::OPenAPIClient::Object::InlineObject1->new(); # InlineObject1 |

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

    try:
        # Umožní editovat údaje přihlášeného uživatele
        api_response = api_instance.edit_put(inlineObject1)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->editPut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let inlineObject1 = ; // InlineObject1

        let mut context = DefaultApi::Context::default();
        let result = client.editPut(inlineObject1, &context).wait();

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

## Scopes

## Parameters

Body parameters

Name | Description
--- | ---
inlineObject1 * |

## Responses

###

# getByEmailGet

Navrátí všechny dostupné informace o uživateli s konkrétním emailem

Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER, ASSISTANT]

    /getByEmail

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/getByEmail?email=user123@email.com"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String email = user123@email.com; // String | Email uživatele

            try {
                inline_response_200_1 result = apiInstance.getByEmailGet(email);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getByEmailGet");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String email = user123@email.com; // String | Email uživatele

            try {
                inline_response_200_1 result = apiInstance.getByEmailGet(email);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#getByEmailGet");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *email = user123@email.com; // Email uživatele (default to null)

    // Navrátí všechny dostupné informace o uživateli s konkrétním emailem
    [apiInstance getByEmailGetWith:email
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var email = user123@email.com; // {String} Email uživatele

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var email = user123@email.com;  // String | Email uživatele (default to null)

                try {
                    // Navrátí všechny dostupné informace o uživateli s konkrétním emailem
                    inline_response_200_1 result = apiInstance.getByEmailGet(email);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getByEmailGet: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $email = user123@email.com; // String | Email uživatele

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $email = user123@email.com; # String | Email uživatele

    eval {
        my $result = $api_instance->getByEmailGet(email => $email);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getByEmailGet: $@\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.DefaultApi()
    email = user123@email.com # String | Email uživatele (default to null)

    try:
        # Navrátí všechny dostupné informace o uživateli s konkrétním emailem
        api_response = api_instance.get_by_email_get(email)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getByEmailGet: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let email = user123@email.com; // String

        let mut context = DefaultApi::Context::default();
        let result = client.getByEmailGet(email, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
email* | String Email uživatele Required

## Responses

###

# getByIDGet

Navrátí všechny dostupné informace o uživateli s konkrétním ID

Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER, ASSISTANT]

    /getByID

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/getByID?id=1"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            Integer id = 1; // Integer | ID uživatele

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer id = 1; // Integer | ID uživatele

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *id = 1; // ID uživatele (default to null)

    // Navrátí všechny dostupné informace o uživateli s konkrétním ID
    [apiInstance getByIDGetWith:id
                  completionHandler: ^(inline_response_200_1 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var id = 1; // {Integer} ID uživatele

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var id = 1;  // Integer | ID uživatele (default to null)

                try {
                    // Navrátí všechny dostupné informace o uživateli s konkrétním ID
                    inline_response_200_1 result = apiInstance.getByIDGet(id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.getByIDGet: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $id = 1; // Integer | ID uživatele

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $id = 1; # Integer | ID uživatele

    eval {
        my $result = $api_instance->getByIDGet(id => $id);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->getByIDGet: $@\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.DefaultApi()
    id = 1 # Integer | ID uživatele (default to null)

    try:
        # Navrátí všechny dostupné informace o uživateli s konkrétním ID
        api_response = api_instance.get_by_id_get(id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->getByIDGet: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let id = 1; // Integer

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
id* | Integer ID uživatele Required

## Responses

###

# infoGet

Navrátí všechny dostupné informace o uživateli

Podle přistupového tokenu najde v databázi, kterému přihlášenému uživateli patří a informace o něm navrátí.

    /info

### Usage and SDK Samples

    curl -X GET \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/info"

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

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

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

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

            try {
                inline_response_200 result = apiInstance.infoGet();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#infoGet");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

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

            try {
                inline_response_200 result = apiInstance.infoGet();
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#infoGet");
                e.printStackTrace();
            }
        }
    }

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

    // Navrátí všechny dostupné informace o uživateli
    [apiInstance infoGetWithCompletionHandler:
                  ^(inline_response_200 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var callback = function(error, data, response) {
      if (error) {
        console.error(error);
      } else {
        console.log('API called successfully. Returned data: ' + data);
      }
    };
    api.infoGet(callback);

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

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

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

                try {
                    // Navrátí všechny dostupné informace o uživateli
                    inline_response_200 result = apiInstance.infoGet();
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.infoGet: " + e.Message );
                }
            }
        }
    }

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

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

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

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

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

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

    try:
        # Navrátí všechny dostupné informace o uživateli
        api_response = api_instance.info_get()
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->infoGet: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {

        let mut context = DefaultApi::Context::default();
        let result = client.infoGet(&context).wait();

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

## Scopes

## Parameters

## Responses

###

# removeDelete

Změní atributy uživatele s konktretním ID

Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER]

    /remove

### Usage and SDK Samples

    curl -X DELETE \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/remove?id=1"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            Integer id = 1; // Integer | ID uživatele

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

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            Integer id = 1; // Integer | ID uživatele

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

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    Integer *id = 1; // ID uživatele (default to null)

    // Změní atributy uživatele s konktretním ID
    [apiInstance removeDeleteWith:id
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var id = 1; // {Integer} ID uživatele

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var id = 1;  // Integer | ID uživatele (default to null)

                try {
                    // Změní atributy uživatele s konktretním ID
                    inline_response_200_2 result = apiInstance.removeDelete(id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.removeDelete: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $id = 1; // Integer | ID uživatele

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $id = 1; # Integer | ID uživatele

    eval {
        my $result = $api_instance->removeDelete(id => $id);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->removeDelete: $@\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.DefaultApi()
    id = 1 # Integer | ID uživatele (default to null)

    try:
        # Změní atributy uživatele s konktretním ID
        api_response = api_instance.remove_delete(id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->removeDelete: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let id = 1; // Integer

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

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
id* | Integer ID uživatele Required

## Responses

###

# removeRolePut

Odebere uživateli zvolenou roli

Mají přístup jen uživatelé s touto rolí [ADMIN]

    /removeRole

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/removeRole?role=role_example&id=56"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String role = role_example; // String | Uživateska role, která bude uživateli odebrána
            Integer id = 56; // Integer | ID uživatele

            try {
                inline_response_200_2 result = apiInstance.removeRolePut(role, id);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#removeRolePut");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String role = role_example; // String | Uživateska role, která bude uživateli odebrána
            Integer id = 56; // Integer | ID uživatele

            try {
                inline_response_200_2 result = apiInstance.removeRolePut(role, id);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#removeRolePut");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *role = role_example; // Uživateska role, která bude uživateli odebrána (default to null)
    Integer *id = 56; // ID uživatele (default to null)

    // Odebere uživateli zvolenou roli
    [apiInstance removeRolePutWith:role
        id:id
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var role = role_example; // {String} Uživateska role, která bude uživateli odebrána
    var id = 56; // {Integer} ID uživatele

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var role = role_example;  // String | Uživateska role, která bude uživateli odebrána (default to null)
                var id = 56;  // Integer | ID uživatele (default to null)

                try {
                    // Odebere uživateli zvolenou roli
                    inline_response_200_2 result = apiInstance.removeRolePut(role, id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.removeRolePut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $role = role_example; // String | Uživateska role, která bude uživateli odebrána
    $id = 56; // Integer | ID uživatele

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $role = role_example; # String | Uživateska role, která bude uživateli odebrána
    my $id = 56; # Integer | ID uživatele

    eval {
        my $result = $api_instance->removeRolePut(role => $role, id => $id);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->removeRolePut: $@\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.DefaultApi()
    role = role_example # String | Uživateska role, která bude uživateli odebrána (default to null)
    id = 56 # Integer | ID uživatele (default to null)

    try:
        # Odebere uživateli zvolenou roli
        api_response = api_instance.remove_role_put(role, id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->removeRolePut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let role = role_example; // String
        let id = 56; // Integer

        let mut context = DefaultApi::Context::default();
        let result = client.removeRolePut(role, id, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
role* | String Uživateska role, která bude uživateli odebrána Required
id* | Integer ID uživatele Required

## Responses

###

# setPasswordPut

Nastaví uživateli nové heslo

Mají přístup jen uživatelé s touto rolí [ADMIN, LEADER]

    /setPassword

### Usage and SDK Samples

    curl -X PUT \
     -H "Accept: application/json" \
     "https://iob04.vas-server.cz:8080/api/user/setPassword?newPassword=newPassword_example&id=56"

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

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

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

            // Create an instance of the API class
            DefaultApi apiInstance = new DefaultApi();
            String newPassword = newPassword_example; // String | Nové uživatelské heslo
            Integer id = 56; // Integer | ID uživatele, pro kterého chceme heslo vygenerovat

            try {
                inline_response_200_2 result = apiInstance.setPasswordPut(newPassword, id);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#setPasswordPut");
                e.printStackTrace();
            }
        }
    }

    import org.openapitools.client.api.DefaultApi;

    public class DefaultApiExample {
        public static void main(String[] args) {
            DefaultApi apiInstance = new DefaultApi();
            String newPassword = newPassword_example; // String | Nové uživatelské heslo
            Integer id = 56; // Integer | ID uživatele, pro kterého chceme heslo vygenerovat

            try {
                inline_response_200_2 result = apiInstance.setPasswordPut(newPassword, id);
                System.out.println(result);
            } catch (ApiException e) {
                System.err.println("Exception when calling DefaultApi#setPasswordPut");
                e.printStackTrace();
            }
        }
    }

    // Create an instance of the API class
    DefaultApi *apiInstance = [[DefaultApi alloc] init];
    String *newPassword = newPassword_example; // Nové uživatelské heslo (default to null)
    Integer *id = 56; // ID uživatele, pro kterého chceme heslo vygenerovat (default to null)

    // Nastaví uživateli nové heslo
    [apiInstance setPasswordPutWith:newPassword
        id:id
                  completionHandler: ^(inline_response_200_2 output, NSError* error) {
        if (output) {
            NSLog(@"%@", output);
        }
        if (error) {
            NSLog(@"Error: %@", error);
        }
    }];

    var RoboCupMsUserApi = require('robo_cup_ms_user_api');

    // Create an instance of the API class
    var api = new RoboCupMsUserApi.DefaultApi()
    var newPassword = newPassword_example; // {String} Nové uživatelské heslo
    var id = 56; // {Integer} ID uživatele, pro kterého chceme heslo vygenerovat

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

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

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

                // Create an instance of the API class
                var apiInstance = new DefaultApi();
                var newPassword = newPassword_example;  // String | Nové uživatelské heslo (default to null)
                var id = 56;  // Integer | ID uživatele, pro kterého chceme heslo vygenerovat (default to null)

                try {
                    // Nastaví uživateli nové heslo
                    inline_response_200_2 result = apiInstance.setPasswordPut(newPassword, id);
                    Debug.WriteLine(result);
                } catch (Exception e) {
                    Debug.Print("Exception when calling DefaultApi.setPasswordPut: " + e.Message );
                }
            }
        }
    }

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

    // Create an instance of the API class
    $api_instance = new OpenAPITools\Client\Api\DefaultApi();
    $newPassword = newPassword_example; // String | Nové uživatelské heslo
    $id = 56; // Integer | ID uživatele, pro kterého chceme heslo vygenerovat

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

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

    # Create an instance of the API class
    my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
    my $newPassword = newPassword_example; # String | Nové uživatelské heslo
    my $id = 56; # Integer | ID uživatele, pro kterého chceme heslo vygenerovat

    eval {
        my $result = $api_instance->setPasswordPut(newPassword => $newPassword, id => $id);
        print Dumper($result);
    };
    if ($@) {
        warn "Exception when calling DefaultApi->setPasswordPut: $@\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.DefaultApi()
    newPassword = newPassword_example # String | Nové uživatelské heslo (default to null)
    id = 56 # Integer | ID uživatele, pro kterého chceme heslo vygenerovat (default to null)

    try:
        # Nastaví uživateli nové heslo
        api_response = api_instance.set_password_put(newPassword, id)
        pprint(api_response)
    except ApiException as e:
        print("Exception when calling DefaultApi->setPasswordPut: %s\n" % e)

    extern crate DefaultApi;

    pub fn main() {
        let newPassword = newPassword_example; // String
        let id = 56; // Integer

        let mut context = DefaultApi::Context::default();
        let result = client.setPasswordPut(newPassword, id, &context).wait();

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

## Scopes

## Parameters

Query parameters

Name | Description
--- | ---
newPassword* | String Nové uživatelské heslo Required
id* | Integer ID uživatele, pro kterého chceme heslo vygenerovat Required

## Responses

###