OpenAPI definition

BookingsRestController

createBooking

Create a new booking

/api/v1/bookings/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/bookings/" \
 -d '{
  "userEmail" : "userEmail",
  "id" : 0,
  "userName" : "userName",
  "eventDescript" : "eventDescript",
  "bussinesName" : "bussinesName",
  "capacity" : 6,
  "status" : "status"
}'

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

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

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

        // Create an instance of the API class
        BookingsRestControllerApi apiInstance = new BookingsRestControllerApi();
        BookingDTO bookingDTO = ; // BookingDTO | 

        try {
            BookingDTO result = apiInstance.createBooking(bookingDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingsRestControllerApi#createBooking");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BookingDTO bookingDTO = new BookingDTO(); // BookingDTO | 

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

import org.openapitools.client.api.BookingsRestControllerApi;

public class BookingsRestControllerApiExample {
    public static void main(String[] args) {
        BookingsRestControllerApi apiInstance = new BookingsRestControllerApi();
        BookingDTO bookingDTO = ; // BookingDTO | 

        try {
            BookingDTO result = apiInstance.createBooking(bookingDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingsRestControllerApi#createBooking");
            e.printStackTrace();
        }
    }
}



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

// Create a new booking
[apiInstance createBookingWith:bookingDTO
              completionHandler: ^(BookingDTO 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.BookingsRestControllerApi()
var bookingDTO = ; // {BookingDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new BookingsRestControllerApi();
            var bookingDTO = new BookingDTO(); // BookingDTO | 

            try {
                // Create a new booking
                BookingDTO result = apiInstance.createBooking(bookingDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingsRestControllerApi.createBooking: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\BookingsRestControllerApi();
$bookingDTO = ; // BookingDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::BookingsRestControllerApi->new();
my $bookingDTO = WWW::OPenAPIClient::Object::BookingDTO->new(); # BookingDTO | 

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

try:
    # Create a new booking
    api_response = api_instance.create_booking(bookingDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BookingsRestControllerApi->createBooking: %s\n" % e)

extern crate BookingsRestControllerApi;

pub fn main() {
    let bookingDTO = ; // BookingDTO

    let mut context = BookingsRestControllerApi::Context::default();
    let result = client.createBooking(bookingDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
bookingDTO *

Responses

Schema

deleteBooking

Delete a booking by its id

/api/v1/bookings/{id}

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/v1/bookings/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.BookingsRestControllerApi;

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

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



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

// Delete a booking by its id
[apiInstance deleteBookingWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Delete a booking by its id
                apiInstance.deleteBooking(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingsRestControllerApi.deleteBooking: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete a booking by its id
    api_instance.delete_booking(id)
except ApiException as e:
    print("Exception when calling BookingsRestControllerApi->deleteBooking: %s\n" % e)

extern crate BookingsRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

getAllBookings

Get all the bookings done

/api/v1/bookings/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/bookings/"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.BookingsRestControllerApi;

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

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



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

// Get all the bookings done
[apiInstance getAllBookingsWithCompletionHandler: 
              ^(array[BookingDTO] 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.BookingsRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllBookings(callback);

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

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

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

            try {
                // Get all the bookings done
                array[BookingDTO] result = apiInstance.getAllBookings();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingsRestControllerApi.getAllBookings: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all the bookings done
    api_response = api_instance.get_all_bookings()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BookingsRestControllerApi->getAllBookings: %s\n" % e)

extern crate BookingsRestControllerApi;

pub fn main() {

    let mut context = BookingsRestControllerApi::Context::default();
    let result = client.getAllBookings(&context).wait();

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

Scopes

Parameters

Responses

Schema

getBooking

Get a single booking by its id

/api/v1/bookings/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/bookings/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.BookingsRestControllerApi;

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

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



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

// Get a single booking by its id
[apiInstance getBookingWith:id
              completionHandler: ^(BookingDTO 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.BookingsRestControllerApi()
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.getBooking(id, callback);

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

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

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

            try {
                // Get a single booking by its id
                BookingDTO result = apiInstance.getBooking(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingsRestControllerApi.getBooking: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a single booking by its id
    api_response = api_instance.get_booking(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BookingsRestControllerApi->getBooking: %s\n" % e)

extern crate BookingsRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

updateBooking

Update a booking that already exists

/api/v1/bookings/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/bookings/{id}" \
 -d '{
  "userEmail" : "userEmail",
  "id" : 0,
  "userName" : "userName",
  "eventDescript" : "eventDescript",
  "bussinesName" : "bussinesName",
  "capacity" : 6,
  "status" : "status"
}'

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

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

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

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

        try {
            BookingDTO result = apiInstance.updateBooking(id, bookingDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingsRestControllerApi#updateBooking");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.BookingsRestControllerApi;

public class BookingsRestControllerApiExample {
    public static void main(String[] args) {
        BookingsRestControllerApi apiInstance = new BookingsRestControllerApi();
        Long id = 789; // Long | 
        BookingDTO bookingDTO = ; // BookingDTO | 

        try {
            BookingDTO result = apiInstance.updateBooking(id, bookingDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling BookingsRestControllerApi#updateBooking");
            e.printStackTrace();
        }
    }
}



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

// Update a booking that already exists
[apiInstance updateBookingWith:id
    bookingDTO:bookingDTO
              completionHandler: ^(BookingDTO 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.BookingsRestControllerApi()
var id = 789; // {Long} 
var bookingDTO = ; // {BookingDTO} 

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

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

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

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

            try {
                // Update a booking that already exists
                BookingDTO result = apiInstance.updateBooking(id, bookingDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling BookingsRestControllerApi.updateBooking: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update a booking that already exists
    api_response = api_instance.update_booking(id, bookingDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling BookingsRestControllerApi->updateBooking: %s\n" % e)

extern crate BookingsRestControllerApi;

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

    let mut context = BookingsRestControllerApi::Context::default();
    let result = client.updateBooking(id, bookingDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
bookingDTO *

Responses

Schema

CommentRestController

createComment

Create a new comment

/api/v1/comments/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/comments/" \
 -d '{
  "eventId" : 6,
  "rate" : 1,
  "id" : 0,
  "comentario" : "comentario",
  "username" : "username"
}'

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

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

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

        // Create an instance of the API class
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        CommentDTO commentDTO = ; // CommentDTO | 

        try {
            CommentDTO result = apiInstance.createComment(commentDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#createComment");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CommentDTO commentDTO = new CommentDTO(); // CommentDTO | 

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

import org.openapitools.client.api.CommentRestControllerApi;

public class CommentRestControllerApiExample {
    public static void main(String[] args) {
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        CommentDTO commentDTO = ; // CommentDTO | 

        try {
            CommentDTO result = apiInstance.createComment(commentDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#createComment");
            e.printStackTrace();
        }
    }
}



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

// Create a new comment
[apiInstance createCommentWith:commentDTO
              completionHandler: ^(CommentDTO 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.CommentRestControllerApi()
var commentDTO = ; // {CommentDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new CommentRestControllerApi();
            var commentDTO = new CommentDTO(); // CommentDTO | 

            try {
                // Create a new comment
                CommentDTO result = apiInstance.createComment(commentDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.createComment: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CommentRestControllerApi();
$commentDTO = ; // CommentDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CommentRestControllerApi->new();
my $commentDTO = WWW::OPenAPIClient::Object::CommentDTO->new(); # CommentDTO | 

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

try:
    # Create a new comment
    api_response = api_instance.create_comment(commentDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->createComment: %s\n" % e)

extern crate CommentRestControllerApi;

pub fn main() {
    let commentDTO = ; // CommentDTO

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.createComment(commentDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
commentDTO *

Responses

Schema

deleteAllComments

Delete all comments

/api/v1/comments/

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/comments/"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CommentRestControllerApi;

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

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



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

// Delete all comments
[apiInstance deleteAllCommentsWithCompletionHandler: 
              ^(array[CommentDTO] 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.CommentRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteAllComments(callback);

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

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

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

            try {
                // Delete all comments
                array[CommentDTO] result = apiInstance.deleteAllComments();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.deleteAllComments: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete all comments
    api_response = api_instance.delete_all_comments()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->deleteAllComments: %s\n" % e)

extern crate CommentRestControllerApi;

pub fn main() {

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.deleteAllComments(&context).wait();

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

Scopes

Parameters

Responses

Schema

deleteComment

Delete a comment by its id

/api/v1/comments/{id}

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/v1/comments/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.CommentRestControllerApi;

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

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



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

// Delete a comment by its id
[apiInstance deleteCommentWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Delete a comment by its id
                apiInstance.deleteComment(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.deleteComment: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete a comment by its id
    api_instance.delete_comment(id)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->deleteComment: %s\n" % e)

extern crate CommentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

getCommentById

Get a comment by its id

/api/v1/comments/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/comments/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.CommentRestControllerApi;

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

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



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

// Get a comment by its id
[apiInstance getCommentByIdWith:id
              completionHandler: ^(CommentDTO 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.CommentRestControllerApi()
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.getCommentById(id, callback);

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

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

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

            try {
                // Get a comment by its id
                CommentDTO result = apiInstance.getCommentById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.getCommentById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a comment by its id
    api_response = api_instance.get_comment_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getCommentById: %s\n" % e)

extern crate CommentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getCommentByUserId

Get comments by user id

/api/v1/comments/user/{userId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/comments/user/{userId}"

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

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

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

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

        try {
            array[CommentDTO] result = apiInstance.getCommentByUserId(userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getCommentByUserId");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.CommentRestControllerApi;

public class CommentRestControllerApiExample {
    public static void main(String[] args) {
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Long userId = 789; // Long | 

        try {
            array[CommentDTO] result = apiInstance.getCommentByUserId(userId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getCommentByUserId");
            e.printStackTrace();
        }
    }
}



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

// Get comments by user id
[apiInstance getCommentByUserIdWith:userId
              completionHandler: ^(array[CommentDTO] 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.CommentRestControllerApi()
var userId = 789; // {Long} 

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

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

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

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

            try {
                // Get comments by user id
                array[CommentDTO] result = apiInstance.getCommentByUserId(userId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.getCommentByUserId: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get comments by user id
    api_response = api_instance.get_comment_by_user_id(userId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getCommentByUserId: %s\n" % e)

extern crate CommentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
userId*	Long (int64) Required

Responses

Schema

getComments

Get all comments

/api/v1/comments/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/comments/"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CommentRestControllerApi;

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

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



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

// Get all comments
[apiInstance getCommentsWithCompletionHandler: 
              ^(array[CommentDTO] 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.CommentRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getComments(callback);

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

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

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

            try {
                // Get all comments
                array[CommentDTO] result = apiInstance.getComments();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.getComments: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all comments
    api_response = api_instance.get_comments()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getComments: %s\n" % e)

extern crate CommentRestControllerApi;

pub fn main() {

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.getComments(&context).wait();

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

Scopes

Parameters

Responses

Schema

getCommentsByRate

Get comments by rate

/api/v1/comments/rate/{rate}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/comments/rate/{rate}"

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

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

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

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

        try {
            array[CommentDTO] result = apiInstance.getCommentsByRate(rate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getCommentsByRate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer rate = new Integer(); // Integer | 

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

import org.openapitools.client.api.CommentRestControllerApi;

public class CommentRestControllerApiExample {
    public static void main(String[] args) {
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Integer rate = 56; // Integer | 

        try {
            array[CommentDTO] result = apiInstance.getCommentsByRate(rate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getCommentsByRate");
            e.printStackTrace();
        }
    }
}



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

// Get comments by rate
[apiInstance getCommentsByRateWith:rate
              completionHandler: ^(array[CommentDTO] 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.CommentRestControllerApi()
var rate = 56; // {Integer} 

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

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

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

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

            try {
                // Get comments by rate
                array[CommentDTO] result = apiInstance.getCommentsByRate(rate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.getCommentsByRate: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getCommentsByRate(rate => $rate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CommentRestControllerApi->getCommentsByRate: $@\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.CommentRestControllerApi()
rate = 56 # Integer |  (default to null)

try:
    # Get comments by rate
    api_response = api_instance.get_comments_by_rate(rate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getCommentsByRate: %s\n" % e)

extern crate CommentRestControllerApi;

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

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.getCommentsByRate(rate, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
rate*	Integer (int32) Required

Responses

Schema

replaceComment

Update a comment by its id

/api/v1/comments/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/comments/{id}" \
 -d '{
  "eventId" : 6,
  "rate" : 1,
  "id" : 0,
  "comentario" : "comentario",
  "username" : "username"
}'

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

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

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

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

        try {
            apiInstance.replaceComment(id, commentDTO);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#replaceComment");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.CommentRestControllerApi;

public class CommentRestControllerApiExample {
    public static void main(String[] args) {
        CommentRestControllerApi apiInstance = new CommentRestControllerApi();
        Long id = 789; // Long | 
        CommentDTO commentDTO = ; // CommentDTO | 

        try {
            apiInstance.replaceComment(id, commentDTO);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#replaceComment");
            e.printStackTrace();
        }
    }
}



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

// Update a comment by its id
[apiInstance replaceCommentWith:id
    commentDTO:commentDTO
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Update a comment by its id
                apiInstance.replaceComment(id, commentDTO);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.replaceComment: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->replaceComment($id, $commentDTO);
} catch (Exception $e) {
    echo 'Exception when calling CommentRestControllerApi->replaceComment: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->replaceComment(id => $id, commentDTO => $commentDTO);
};
if ($@) {
    warn "Exception when calling CommentRestControllerApi->replaceComment: $@\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.CommentRestControllerApi()
id = 789 # Long |  (default to null)
commentDTO =  # CommentDTO | 

try:
    # Update a comment by its id
    api_instance.replace_comment(id, commentDTO)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->replaceComment: %s\n" % e)

extern crate CommentRestControllerApi;

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

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.replaceComment(id, commentDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
commentDTO *

Responses

EventRestController

createEvent

Create a new event

/api/v1/events/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/events/" \
 -d '{
  "description" : "description",
  "id" : 0,
  "title" : "title",
  "type" : "type",
  "category" : "category"
}'

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

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

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

        // Create an instance of the API class
        EventRestControllerApi apiInstance = new EventRestControllerApi();
        EventDTO eventDTO = ; // EventDTO | 

        try {
            Event result = apiInstance.createEvent(eventDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventRestControllerApi#createEvent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final EventDTO eventDTO = new EventDTO(); // EventDTO | 

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

import org.openapitools.client.api.EventRestControllerApi;

public class EventRestControllerApiExample {
    public static void main(String[] args) {
        EventRestControllerApi apiInstance = new EventRestControllerApi();
        EventDTO eventDTO = ; // EventDTO | 

        try {
            Event result = apiInstance.createEvent(eventDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventRestControllerApi#createEvent");
            e.printStackTrace();
        }
    }
}



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

// Create a new event
[apiInstance createEventWith:eventDTO
              completionHandler: ^(Event 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.EventRestControllerApi()
var eventDTO = ; // {EventDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EventRestControllerApi();
            var eventDTO = new EventDTO(); // EventDTO | 

            try {
                // Create a new event
                Event result = apiInstance.createEvent(eventDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventRestControllerApi.createEvent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventRestControllerApi();
$eventDTO = ; // EventDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventRestControllerApi->new();
my $eventDTO = WWW::OPenAPIClient::Object::EventDTO->new(); # EventDTO | 

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

try:
    # Create a new event
    api_response = api_instance.create_event(eventDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventRestControllerApi->createEvent: %s\n" % e)

extern crate EventRestControllerApi;

pub fn main() {
    let eventDTO = ; // EventDTO

    let mut context = EventRestControllerApi::Context::default();
    let result = client.createEvent(eventDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
eventDTO *

Responses

Schema

deleteEvent

Delete an event by its id

/api/v1/events/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/events/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventRestControllerApi;

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

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



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

// Delete an event by its id
[apiInstance deleteEventWith:id
              completionHandler: ^(EventDTO 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.EventRestControllerApi()
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.deleteEvent(id, callback);

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

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

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

            try {
                // Delete an event by its id
                EventDTO result = apiInstance.deleteEvent(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventRestControllerApi.deleteEvent: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete an event by its id
    api_response = api_instance.delete_event(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventRestControllerApi->deleteEvent: %s\n" % e)

extern crate EventRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getAllEvents

Get all the events

/api/v1/events/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/events/"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.EventRestControllerApi;

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

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



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

// Get all the events
[apiInstance getAllEventsWithCompletionHandler: 
              ^(array[EventDTO] 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.EventRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllEvents(callback);

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

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

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

            try {
                // Get all the events
                array[EventDTO] result = apiInstance.getAllEvents();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventRestControllerApi.getAllEvents: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all the events
    api_response = api_instance.get_all_events()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventRestControllerApi->getAllEvents: %s\n" % e)

extern crate EventRestControllerApi;

pub fn main() {

    let mut context = EventRestControllerApi::Context::default();
    let result = client.getAllEvents(&context).wait();

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

Scopes

Parameters

Responses

Schema

getAllEventsByType

Get all the events of a certain type

/api/v1/events/type/{type}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/events/type/{type}"

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

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

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

        // Create an instance of the API class
        EventRestControllerApi apiInstance = new EventRestControllerApi();
        String type = type_example; // String | 

        try {
            array[EventDTO] result = apiInstance.getAllEventsByType(type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventRestControllerApi#getAllEventsByType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventRestControllerApi;

public class EventRestControllerApiExample {
    public static void main(String[] args) {
        EventRestControllerApi apiInstance = new EventRestControllerApi();
        String type = type_example; // String | 

        try {
            array[EventDTO] result = apiInstance.getAllEventsByType(type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventRestControllerApi#getAllEventsByType");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
EventRestControllerApi *apiInstance = [[EventRestControllerApi alloc] init];
String *type = type_example; //  (default to null)

// Get all the events of a certain type
[apiInstance getAllEventsByTypeWith:type
              completionHandler: ^(array[EventDTO] 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.EventRestControllerApi()
var type = type_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EventRestControllerApi();
            var type = type_example;  // String |  (default to null)

            try {
                // Get all the events of a certain type
                array[EventDTO] result = apiInstance.getAllEventsByType(type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventRestControllerApi.getAllEventsByType: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventRestControllerApi();
$type = type_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventRestControllerApi->new();
my $type = type_example; # String | 

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

try:
    # Get all the events of a certain type
    api_response = api_instance.get_all_events_by_type(type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventRestControllerApi->getAllEventsByType: %s\n" % e)

extern crate EventRestControllerApi;

pub fn main() {
    let type = type_example; // String

    let mut context = EventRestControllerApi::Context::default();
    let result = client.getAllEventsByType(type, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
type*	String Required

Responses

Schema

getEvent

Get a single event by its id

/api/v1/events/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/events/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventRestControllerApi;

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

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



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

// Get a single event by its id
[apiInstance getEventWith:id
              completionHandler: ^(EventDTO 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.EventRestControllerApi()
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.getEvent(id, callback);

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

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

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

            try {
                // Get a single event by its id
                EventDTO result = apiInstance.getEvent(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventRestControllerApi.getEvent: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a single event by its id
    api_response = api_instance.get_event(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventRestControllerApi->getEvent: %s\n" % e)

extern crate EventRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

replaceEvent

Update an event that already exists

/api/v1/events/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/events/{id}" \
 -d '{
  "imageFile" : {
    "binaryStream" : "{}"
  },
  "description" : "description",
  "id" : 0,
  "title" : "title",
  "type" : "type",
  "category" : "category"
}'

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

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

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

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

        try {
            EventDTO result = apiInstance.replaceEvent(id, event);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventRestControllerApi#replaceEvent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventRestControllerApi;

public class EventRestControllerApiExample {
    public static void main(String[] args) {
        EventRestControllerApi apiInstance = new EventRestControllerApi();
        Long id = 789; // Long | 
        Event event = ; // Event | 

        try {
            EventDTO result = apiInstance.replaceEvent(id, event);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventRestControllerApi#replaceEvent");
            e.printStackTrace();
        }
    }
}



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

// Update an event that already exists
[apiInstance replaceEventWith:id
    event:event
              completionHandler: ^(EventDTO 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.EventRestControllerApi()
var id = 789; // {Long} 
var event = ; // {Event} 

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

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

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

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

            try {
                // Update an event that already exists
                EventDTO result = apiInstance.replaceEvent(id, event);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventRestControllerApi.replaceEvent: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update an event that already exists
    api_response = api_instance.replace_event(id, event)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventRestControllerApi->replaceEvent: %s\n" % e)

extern crate EventRestControllerApi;

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

    let mut context = EventRestControllerApi::Context::default();
    let result = client.replaceEvent(id, event, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
event *

Responses

Schema

LoginRestController

login

/api/auth/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/auth/login" \
 -d '{
  "password" : "password",
  "username" : "username"
}'

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

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

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

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

        try {
            AuthResponse result = apiInstance.login(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#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.LoginRestControllerApi;

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

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



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

[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.LoginRestControllerApi()
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 LoginRestControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

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

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

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

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

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

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

eval {
    my $result = $api_instance->login(loginRequest => $loginRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestControllerApi->login: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

extern crate LoginRestControllerApi;

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

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

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

Scopes

Parameters

Body parameters

Name	Description
loginRequest *

Responses

logout

/api/auth/logout

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/api/auth/logout"

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

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

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

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

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

import '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.LoginRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

eval {
    my $result = $api_instance->logout();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestControllerApi->logout: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

extern crate LoginRestControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

refreshToken

/api/auth/refresh

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/api/auth/refresh"

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

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

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

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

        try {
            AuthResponse result = apiInstance.refreshToken(refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestControllerApi#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.LoginRestControllerApi;

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

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



// Create an instance of the API class
LoginRestControllerApi *apiInstance = [[LoginRestControllerApi 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.LoginRestControllerApi()
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 LoginRestControllerApi();
            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 LoginRestControllerApi.refreshToken: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->refreshToken(refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestControllerApi->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.LoginRestControllerApi()
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 LoginRestControllerApi->refreshToken: %s\n" % e)

extern crate LoginRestControllerApi;

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

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

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

Scopes

Parameters

Responses

Schema

TicketRestController

createTicket

Create a new ticket

/api/v1/tickets/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/tickets/" \
 -d '{
  "gender" : "gender",
  "userEmail" : "userEmail",
  "id" : 0,
  "title" : "title",
  "category" : "category",
  "dni" : "dni",
  "ticketName" : "ticketName"
}'

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

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

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

        // Create an instance of the API class
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        TicketDTO ticketDTO = ; // TicketDTO | 

        try {
            TicketDTO result = apiInstance.createTicket(ticketDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#createTicket");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TicketDTO ticketDTO = new TicketDTO(); // TicketDTO | 

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

import org.openapitools.client.api.TicketRestControllerApi;

public class TicketRestControllerApiExample {
    public static void main(String[] args) {
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        TicketDTO ticketDTO = ; // TicketDTO | 

        try {
            TicketDTO result = apiInstance.createTicket(ticketDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#createTicket");
            e.printStackTrace();
        }
    }
}



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

// Create a new ticket
[apiInstance createTicketWith:ticketDTO
              completionHandler: ^(TicketDTO 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.TicketRestControllerApi()
var ticketDTO = ; // {TicketDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketRestControllerApi();
            var ticketDTO = new TicketDTO(); // TicketDTO | 

            try {
                // Create a new ticket
                TicketDTO result = apiInstance.createTicket(ticketDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.createTicket: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketRestControllerApi();
$ticketDTO = ; // TicketDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TicketRestControllerApi->new();
my $ticketDTO = WWW::OPenAPIClient::Object::TicketDTO->new(); # TicketDTO | 

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

try:
    # Create a new ticket
    api_response = api_instance.create_ticket(ticketDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->createTicket: %s\n" % e)

extern crate TicketRestControllerApi;

pub fn main() {
    let ticketDTO = ; // TicketDTO

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.createTicket(ticketDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
ticketDTO *

Responses

Schema

deleteAllTickets

Delete all tickets

/api/v1/tickets/

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/v1/tickets/"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.TicketRestControllerApi;

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

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



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

// Delete all tickets
[apiInstance deleteAllTicketsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Delete all tickets
                apiInstance.deleteAllTickets();
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.deleteAllTickets: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete all tickets
    api_instance.delete_all_tickets()
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->deleteAllTickets: %s\n" % e)

extern crate TicketRestControllerApi;

pub fn main() {

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.deleteAllTickets(&context).wait();

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

Scopes

Parameters

Responses

deleteTicket

Delete a ticket by its id

/api/v1/tickets/{id}

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/v1/tickets/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TicketRestControllerApi;

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

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



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

// Delete a ticket by its id
[apiInstance deleteTicketWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Delete a ticket by its id
                apiInstance.deleteTicket(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.deleteTicket: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete a ticket by its id
    api_instance.delete_ticket(id)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->deleteTicket: %s\n" % e)

extern crate TicketRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

getAllTickets

Get all the tickets

/api/v1/tickets/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/tickets/"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.TicketRestControllerApi;

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

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



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

// Get all the tickets
[apiInstance getAllTicketsWithCompletionHandler: 
              ^(array[TicketDTO] 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.TicketRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllTickets(callback);

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

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

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

            try {
                // Get all the tickets
                array[TicketDTO] result = apiInstance.getAllTickets();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.getAllTickets: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all the tickets
    api_response = api_instance.get_all_tickets()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->getAllTickets: %s\n" % e)

extern crate TicketRestControllerApi;

pub fn main() {

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.getAllTickets(&context).wait();

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

Scopes

Parameters

Responses

Schema

getTicketById

Get a single ticket by its id

/api/v1/tickets/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/tickets/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TicketRestControllerApi;

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

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



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

// Get a single ticket by its id
[apiInstance getTicketByIdWith:id
              completionHandler: ^(TicketDTO 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.TicketRestControllerApi()
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.getTicketById(id, callback);

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

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

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

            try {
                // Get a single ticket by its id
                TicketDTO result = apiInstance.getTicketById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.getTicketById: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a single ticket by its id
    api_response = api_instance.get_ticket_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->getTicketById: %s\n" % e)

extern crate TicketRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getTicketsByCategory

Get all the tickets of a certain category

/api/v1/tickets/category/{category}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/tickets/category/{category}"

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

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

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

        // Create an instance of the API class
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String category = category_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByCategory(category);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByCategory");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TicketRestControllerApi;

public class TicketRestControllerApiExample {
    public static void main(String[] args) {
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String category = category_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByCategory(category);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByCategory");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
TicketRestControllerApi *apiInstance = [[TicketRestControllerApi alloc] init];
String *category = category_example; //  (default to null)

// Get all the tickets of a certain category
[apiInstance getTicketsByCategoryWith:category
              completionHandler: ^(array[TicketDTO] 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.TicketRestControllerApi()
var category = category_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketRestControllerApi();
            var category = category_example;  // String |  (default to null)

            try {
                // Get all the tickets of a certain category
                array[TicketDTO] result = apiInstance.getTicketsByCategory(category);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.getTicketsByCategory: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketRestControllerApi();
$category = category_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TicketRestControllerApi->new();
my $category = category_example; # String | 

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

try:
    # Get all the tickets of a certain category
    api_response = api_instance.get_tickets_by_category(category)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->getTicketsByCategory: %s\n" % e)

extern crate TicketRestControllerApi;

pub fn main() {
    let category = category_example; // String

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.getTicketsByCategory(category, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
category*	String Required

Responses

Schema

getTicketsByDni

Get all the tickets of a certain user by dni

/api/v1/tickets/dni/{dni}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/tickets/dni/{dni}?dni=dni_example"

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

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

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

        // Create an instance of the API class
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String dni = dni_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByDni(dni);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByDni");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TicketRestControllerApi;

public class TicketRestControllerApiExample {
    public static void main(String[] args) {
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String dni = dni_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByDni(dni);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByDni");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
TicketRestControllerApi *apiInstance = [[TicketRestControllerApi alloc] init];
String *dni = dni_example; //  (default to null)

// Get all the tickets of a certain user by dni
[apiInstance getTicketsByDniWith:dni
              completionHandler: ^(array[TicketDTO] 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.TicketRestControllerApi()
var dni = dni_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketRestControllerApi();
            var dni = dni_example;  // String |  (default to null)

            try {
                // Get all the tickets of a certain user by dni
                array[TicketDTO] result = apiInstance.getTicketsByDni(dni);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.getTicketsByDni: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketRestControllerApi();
$dni = dni_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TicketRestControllerApi->new();
my $dni = dni_example; # String | 

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

try:
    # Get all the tickets of a certain user by dni
    api_response = api_instance.get_tickets_by_dni(dni)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->getTicketsByDni: %s\n" % e)

extern crate TicketRestControllerApi;

pub fn main() {
    let dni = dni_example; // String

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.getTicketsByDni(dni, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
dni*	String Required

Responses

Schema

getTicketsByTitle

Get all the tickets of a certain title

/api/v1/tickets/title/{title}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/tickets/title/{title}?title=title_example"

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

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

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

        // Create an instance of the API class
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String title = title_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByTitle(title);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByTitle");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TicketRestControllerApi;

public class TicketRestControllerApiExample {
    public static void main(String[] args) {
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String title = title_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByTitle(title);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByTitle");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
TicketRestControllerApi *apiInstance = [[TicketRestControllerApi alloc] init];
String *title = title_example; //  (default to null)

// Get all the tickets of a certain title
[apiInstance getTicketsByTitleWith:title
              completionHandler: ^(array[TicketDTO] 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.TicketRestControllerApi()
var title = title_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketRestControllerApi();
            var title = title_example;  // String |  (default to null)

            try {
                // Get all the tickets of a certain title
                array[TicketDTO] result = apiInstance.getTicketsByTitle(title);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.getTicketsByTitle: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketRestControllerApi();
$title = title_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TicketRestControllerApi->new();
my $title = title_example; # String | 

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

try:
    # Get all the tickets of a certain title
    api_response = api_instance.get_tickets_by_title(title)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->getTicketsByTitle: %s\n" % e)

extern crate TicketRestControllerApi;

pub fn main() {
    let title = title_example; // String

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.getTicketsByTitle(title, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
title*	String Required

Responses

Schema

getTicketsByTitleAndGender

Get all the tickets of a certain gender

/api/v1/tickets/gender/{gender}/{title}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/tickets/gender/{gender}/{title}"

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

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

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

        // Create an instance of the API class
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String gender = gender_example; // String | 
        String title = title_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByTitleAndGender(gender, title);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByTitleAndGender");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String gender = new String(); // String | 
final String title = new String(); // String | 

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

import org.openapitools.client.api.TicketRestControllerApi;

public class TicketRestControllerApiExample {
    public static void main(String[] args) {
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String gender = gender_example; // String | 
        String title = title_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByTitleAndGender(gender, title);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByTitleAndGender");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
TicketRestControllerApi *apiInstance = [[TicketRestControllerApi alloc] init];
String *gender = gender_example; //  (default to null)
String *title = title_example; //  (default to null)

// Get all the tickets of a certain gender
[apiInstance getTicketsByTitleAndGenderWith:gender
    title:title
              completionHandler: ^(array[TicketDTO] 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.TicketRestControllerApi()
var gender = gender_example; // {String} 
var title = title_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketRestControllerApi();
            var gender = gender_example;  // String |  (default to null)
            var title = title_example;  // String |  (default to null)

            try {
                // Get all the tickets of a certain gender
                array[TicketDTO] result = apiInstance.getTicketsByTitleAndGender(gender, title);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.getTicketsByTitleAndGender: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketRestControllerApi();
$gender = gender_example; // String | 
$title = title_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TicketRestControllerApi->new();
my $gender = gender_example; # String | 
my $title = title_example; # String | 

eval {
    my $result = $api_instance->getTicketsByTitleAndGender(gender => $gender, title => $title);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TicketRestControllerApi->getTicketsByTitleAndGender: $@\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.TicketRestControllerApi()
gender = gender_example # String |  (default to null)
title = title_example # String |  (default to null)

try:
    # Get all the tickets of a certain gender
    api_response = api_instance.get_tickets_by_title_and_gender(gender, title)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->getTicketsByTitleAndGender: %s\n" % e)

extern crate TicketRestControllerApi;

pub fn main() {
    let gender = gender_example; // String
    let title = title_example; // String

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.getTicketsByTitleAndGender(gender, title, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
gender*	String Required
title*	String Required

Responses

Schema

getTicketsByUserOwner

Get all the tickets of a certain userOwner

/api/v1/tickets/userOwner/{userOwner}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/tickets/userOwner/{userOwner}?userOwner=userOwner_example"

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

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

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

        // Create an instance of the API class
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String userOwner = userOwner_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByUserOwner(userOwner);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByUserOwner");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TicketRestControllerApi;

public class TicketRestControllerApiExample {
    public static void main(String[] args) {
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        String userOwner = userOwner_example; // String | 

        try {
            array[TicketDTO] result = apiInstance.getTicketsByUserOwner(userOwner);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#getTicketsByUserOwner");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
TicketRestControllerApi *apiInstance = [[TicketRestControllerApi alloc] init];
String *userOwner = userOwner_example; //  (default to null)

// Get all the tickets of a certain userOwner
[apiInstance getTicketsByUserOwnerWith:userOwner
              completionHandler: ^(array[TicketDTO] 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.TicketRestControllerApi()
var userOwner = userOwner_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TicketRestControllerApi();
            var userOwner = userOwner_example;  // String |  (default to null)

            try {
                // Get all the tickets of a certain userOwner
                array[TicketDTO] result = apiInstance.getTicketsByUserOwner(userOwner);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.getTicketsByUserOwner: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TicketRestControllerApi();
$userOwner = userOwner_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TicketRestControllerApi->new();
my $userOwner = userOwner_example; # String | 

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

try:
    # Get all the tickets of a certain userOwner
    api_response = api_instance.get_tickets_by_user_owner(userOwner)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->getTicketsByUserOwner: %s\n" % e)

extern crate TicketRestControllerApi;

pub fn main() {
    let userOwner = userOwner_example; // String

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.getTicketsByUserOwner(userOwner, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
userOwner*	String Required

Responses

Schema

updateTicket

Update a ticket that already exists

/api/v1/tickets/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/tickets/{id}" \
 -d '{
  "gender" : "gender",
  "userEmail" : "userEmail",
  "id" : 0,
  "title" : "title",
  "category" : "category",
  "dni" : "dni",
  "ticketName" : "ticketName"
}'

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

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

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

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

        try {
            TicketDTO result = apiInstance.updateTicket(id, ticketDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#updateTicket");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.TicketRestControllerApi;

public class TicketRestControllerApiExample {
    public static void main(String[] args) {
        TicketRestControllerApi apiInstance = new TicketRestControllerApi();
        Long id = 789; // Long | 
        TicketDTO ticketDTO = ; // TicketDTO | 

        try {
            TicketDTO result = apiInstance.updateTicket(id, ticketDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TicketRestControllerApi#updateTicket");
            e.printStackTrace();
        }
    }
}



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

// Update a ticket that already exists
[apiInstance updateTicketWith:id
    ticketDTO:ticketDTO
              completionHandler: ^(TicketDTO 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.TicketRestControllerApi()
var id = 789; // {Long} 
var ticketDTO = ; // {TicketDTO} 

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

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

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

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

            try {
                // Update a ticket that already exists
                TicketDTO result = apiInstance.updateTicket(id, ticketDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TicketRestControllerApi.updateTicket: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update a ticket that already exists
    api_response = api_instance.update_ticket(id, ticketDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TicketRestControllerApi->updateTicket: %s\n" % e)

extern crate TicketRestControllerApi;

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

    let mut context = TicketRestControllerApi::Context::default();
    let result = client.updateTicket(id, ticketDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
ticketDTO *

Responses

Schema

UserRestController

createUser

Create a new user

/api/v1/users/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users/" \
 -d '{
  "password" : "password",
  "phone" : "phone",
  "roles" : [ "roles", "roles" ],
  "name" : "name",
  "id" : 0,
  "email" : "email"
}'

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();
        CreateRequestUserDTO createRequestUserDTO = ; // CreateRequestUserDTO | 

        try {
            CreateRequestUserDTO result = apiInstance.createUser(createRequestUserDTO);
            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 CreateRequestUserDTO createRequestUserDTO = new CreateRequestUserDTO(); // CreateRequestUserDTO | 

try {
    final result = await api_instance.createUser(createRequestUserDTO);
    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();
        CreateRequestUserDTO createRequestUserDTO = ; // CreateRequestUserDTO | 

        try {
            CreateRequestUserDTO result = apiInstance.createUser(createRequestUserDTO);
            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];
CreateRequestUserDTO *createRequestUserDTO = ; // 

// Create a new user
[apiInstance createUserWith:createRequestUserDTO
              completionHandler: ^(CreateRequestUserDTO 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 createRequestUserDTO = ; // {CreateRequestUserDTO} 

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

            try {
                // Create a new user
                CreateRequestUserDTO result = apiInstance.createUser(createRequestUserDTO);
                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();
$createRequestUserDTO = ; // CreateRequestUserDTO | 

try {
    $result = $api_instance->createUser($createRequestUserDTO);
    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 $createRequestUserDTO = WWW::OPenAPIClient::Object::CreateRequestUserDTO->new(); # CreateRequestUserDTO | 

eval {
    my $result = $api_instance->createUser(createRequestUserDTO => $createRequestUserDTO);
    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()
createRequestUserDTO =  # CreateRequestUserDTO | 

try:
    # Create a new user
    api_response = api_instance.create_user(createRequestUserDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->createUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let createRequestUserDTO = ; // CreateRequestUserDTO

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

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

Scopes

Parameters

Body parameters

Name	Description
createRequestUserDTO *

Responses

Schema

createUserImage

Create a user image

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

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/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 | 
        CreateUserImageRequest createUserImageRequest = ; // CreateUserImageRequest | 

        try {
            Object result = apiInstance.createUserImage(id, createUserImageRequest);
            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 CreateUserImageRequest createUserImageRequest = new CreateUserImageRequest(); // CreateUserImageRequest | 

try {
    final result = await api_instance.createUserImage(id, createUserImageRequest);
    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 | 
        CreateUserImageRequest createUserImageRequest = ; // CreateUserImageRequest | 

        try {
            Object result = apiInstance.createUserImage(id, createUserImageRequest);
            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)
CreateUserImageRequest *createUserImageRequest = ; //  (optional)

// Create a user image
[apiInstance createUserImageWith:id
    createUserImageRequest:createUserImageRequest
              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 = {
  'createUserImageRequest':  // {CreateUserImageRequest} 
};

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 createUserImageRequest = new CreateUserImageRequest(); // CreateUserImageRequest |  (optional) 

            try {
                // Create a user image
                Object result = apiInstance.createUserImage(id, createUserImageRequest);
                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 | 
$createUserImageRequest = ; // CreateUserImageRequest | 

try {
    $result = $api_instance->createUserImage($id, $createUserImageRequest);
    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 $createUserImageRequest = WWW::OPenAPIClient::Object::CreateUserImageRequest->new(); # CreateUserImageRequest | 

eval {
    my $result = $api_instance->createUserImage(id => $id, createUserImageRequest => $createUserImageRequest);
    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)
createUserImageRequest =  # CreateUserImageRequest |  (optional)

try:
    # Create a user image
    api_response = api_instance.create_user_image(id, createUserImageRequest=createUserImageRequest)
    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 createUserImageRequest = ; // CreateUserImageRequest

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
createUserImageRequest

Responses

Schema

deleteAllUsers

Delete all users

/api/v1/users/

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/users/"

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 {
            array[UserDTO] result = apiInstance.deleteAllUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteAllUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Delete all users
[apiInstance deleteAllUsersWithCompletionHandler: 
              ^(array[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.deleteAllUsers(callback);

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

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

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

            try {
                // Delete all users
                array[UserDTO] result = apiInstance.deleteAllUsers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteAllUsers: " + 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->deleteAllUsers();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->deleteAllUsers: ', $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->deleteAllUsers();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->deleteAllUsers: $@\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:
    # Delete all users
    api_response = api_instance.delete_all_users()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteAllUsers: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

deleteUser

Delete a user by its id

/api/v1/users/{id}

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/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 {
            apiInstance.deleteUser(id);
        } 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 {
            apiInstance.deleteUser(id);
        } 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)

// Delete a user by its id
[apiInstance deleteUserWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
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 {
                // Delete a user by its id
                apiInstance.deleteUser(id);
            } 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 {
    $api_instance->deleteUser($id);
} 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 {
    $api_instance->deleteUser(id => $id);
};
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:
    # Delete a user by its id
    api_instance.delete_user(id)
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

deleteUserImage

Delete a user image

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

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/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.deleteUserImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUserImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.deleteUserImage(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteUserImage: $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.deleteUserImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUserImage");
            e.printStackTrace();
        }
    }
}



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

// Delete a user image
[apiInstance deleteUserImageWith: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.deleteUserImage(id, callback);

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

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

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

            try {
                // Delete a user image
                Object result = apiInstance.deleteUserImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteUserImage: " + 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->deleteUserImage($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->deleteUserImage: ', $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->deleteUserImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->deleteUserImage: $@\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:
    # Delete a user image
    api_response = api_instance.delete_user_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteUserImage: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUser

Get a single user by its id

/api/v1/users/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/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)

// Get a single user by its id
[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 {
                // Get a single user by its id
                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:
    # Get a single user by its id
    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

Get a user image

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

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/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)

// Get a user image
[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 {
                // Get a user image
                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:
    # Get a user image
    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

getUsers

Get all users

/api/v1/users/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/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 {
            PagedModelUserDTO 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 {
            PagedModelUserDTO 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)

// Get all users
[apiInstance getUsersWith:pageable
              completionHandler: ^(PagedModelUserDTO 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 {
                // Get all users
                PagedModelUserDTO 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:
    # Get all users
    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

Get all the users

/api/v1/users/me

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/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];

// Get all the users
[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 {
                // Get all the users
                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:
    # Get all the users
    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

replaceUser

Update a user that already exists

/api/v1/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users/{id}" \
 -d '{
  "password" : "password",
  "phone" : "phone",
  "roles" : [ "roles", "roles" ],
  "name" : "name",
  "id" : 0,
  "email" : "email"
}'

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 | 
        CreateRequestUserDTO createRequestUserDTO = ; // CreateRequestUserDTO | 

        try {
            UserDTO result = apiInstance.replaceUser(id, createRequestUserDTO);
            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 CreateRequestUserDTO createRequestUserDTO = new CreateRequestUserDTO(); // CreateRequestUserDTO | 

try {
    final result = await api_instance.replaceUser(id, createRequestUserDTO);
    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 | 
        CreateRequestUserDTO createRequestUserDTO = ; // CreateRequestUserDTO | 

        try {
            UserDTO result = apiInstance.replaceUser(id, createRequestUserDTO);
            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)
CreateRequestUserDTO *createRequestUserDTO = ; // 

// Update a user that already exists
[apiInstance replaceUserWith:id
    createRequestUserDTO:createRequestUserDTO
              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 createRequestUserDTO = ; // {CreateRequestUserDTO} 

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

            try {
                // Update a user that already exists
                UserDTO result = apiInstance.replaceUser(id, createRequestUserDTO);
                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 | 
$createRequestUserDTO = ; // CreateRequestUserDTO | 

try {
    $result = $api_instance->replaceUser($id, $createRequestUserDTO);
    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 $createRequestUserDTO = WWW::OPenAPIClient::Object::CreateRequestUserDTO->new(); # CreateRequestUserDTO | 

eval {
    my $result = $api_instance->replaceUser(id => $id, createRequestUserDTO => $createRequestUserDTO);
    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)
createRequestUserDTO =  # CreateRequestUserDTO | 

try:
    # Update a user that already exists
    api_response = api_instance.replace_user(id, createRequestUserDTO)
    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 createRequestUserDTO = ; // CreateRequestUserDTO

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
createRequestUserDTO *

Responses

Schema

replaceUserImage

Replace a user image

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

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/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 | 
        ReplaceUserImageRequest replaceUserImageRequest = ; // ReplaceUserImageRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.replaceUserImage(id, replaceUserImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceUserImage: $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 | 
        ReplaceUserImageRequest replaceUserImageRequest = ; // ReplaceUserImageRequest | 

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



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

// Replace a user image
[apiInstance replaceUserImageWith:id
    replaceUserImageRequest:replaceUserImageRequest
              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 replaceUserImageRequest = ; // {ReplaceUserImageRequest} 

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

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

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

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

            try {
                // Replace a user image
                Object result = apiInstance.replaceUserImage(id, replaceUserImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.replaceUserImage: " + 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 | 
$replaceUserImageRequest = ; // ReplaceUserImageRequest | 

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

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

try:
    # Replace a user image
    api_response = api_instance.replace_user_image(id, replaceUserImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->replaceUserImage: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
replaceUserImageRequest *

Responses

Schema

OpenAPI definition

API and SDK Documentation

BookingsRestController

createBooking

Usage and SDK Samples

Scopes

Parameters

Responses

deleteBooking

Usage and SDK Samples

Scopes

Parameters

Responses

getAllBookings

Usage and SDK Samples

Scopes

Parameters

Responses

getBooking

Usage and SDK Samples

Scopes

Parameters

Responses

updateBooking

Usage and SDK Samples

Scopes

Parameters

Responses

CommentRestController

createComment

Usage and SDK Samples

Scopes

Parameters

Responses

deleteAllComments

Usage and SDK Samples

Scopes

Parameters

Responses

deleteComment

Usage and SDK Samples

Scopes

Parameters

Responses

getCommentById

Usage and SDK Samples

Scopes

Parameters

Responses

getCommentByUserId

Usage and SDK Samples

Scopes

Parameters

Responses

getComments

Usage and SDK Samples

Scopes

Parameters

Responses

getCommentsByRate

Usage and SDK Samples

Scopes

Parameters

Responses

replaceComment

Usage and SDK Samples

Scopes

Parameters

Responses

EventRestController

createEvent

Usage and SDK Samples

Scopes

Parameters

Responses

deleteEvent

Usage and SDK Samples

Scopes

Parameters

Responses