OpenAPI definition

CommentRestController

createComment


/api/courses/{courseId}/comments

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/api/courses/{courseId}/comments?text=text_example"

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 courseId = 789; // Long | 
        String text = text_example; // String | 

        try {
            Object result = apiInstance.createComment(courseId, text);
            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 Long courseId = new Long(); // Long | 
final String text = new String(); // String | 

try {
    final result = await api_instance.createComment(courseId, text);
    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();
        Long courseId = 789; // Long | 
        String text = text_example; // String | 

        try {
            Object result = apiInstance.createComment(courseId, text);
            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];
Long *courseId = 789; //  (default to null)
String *text = text_example; //  (default to null)

[apiInstance createCommentWith:courseId
    text:text
              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.CommentRestControllerApi()
var courseId = 789; // {Long} 
var text = text_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createComment(courseId, text, 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 courseId = 789;  // Long |  (default to null)
            var text = text_example;  // String |  (default to null)

            try {
                Object result = apiInstance.createComment(courseId, text);
                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();
$courseId = 789; // Long | 
$text = text_example; // String | 

try {
    $result = $api_instance->createComment($courseId, $text);
    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 $courseId = 789; # Long | 
my $text = text_example; # String | 

eval {
    my $result = $api_instance->createComment(courseId => $courseId, text => $text);
    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()
courseId = 789 # Long |  (default to null)
text = text_example # String |  (default to null)

try:
    api_response = api_instance.create_comment(courseId, text)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->createComment: %s\n" % e)
extern crate CommentRestControllerApi;

pub fn main() {
    let courseId = 789; // Long
    let text = text_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
courseId*
Long (int64)
Required
Query parameters
Name Description
text*
String
Required

Responses

deleteComment


/api/courses/{courseId}/comments/{commentId}

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/courses/{courseId}/comments/{commentId}"

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 courseId = 789; // Long | 
        Long commentId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long courseId = new Long(); // Long | 
final Long commentId = new Long(); // Long | 

try {
    final result = await api_instance.deleteComment(courseId, commentId);
    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 courseId = 789; // Long | 
        Long commentId = 789; // Long | 

        try {
            apiInstance.deleteComment(courseId, commentId);
        } 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 *courseId = 789; //  (default to null)
Long *commentId = 789; //  (default to null)

[apiInstance deleteCommentWith:courseId
    commentId:commentId
              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 courseId = 789; // {Long} 
var commentId = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteComment(courseId, commentId, 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 courseId = 789;  // Long |  (default to null)
            var commentId = 789;  // Long |  (default to null)

            try {
                apiInstance.deleteComment(courseId, commentId);
            } 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();
$courseId = 789; // Long | 
$commentId = 789; // Long | 

try {
    $api_instance->deleteComment($courseId, $commentId);
} 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 $courseId = 789; # Long | 
my $commentId = 789; # Long | 

eval {
    $api_instance->deleteComment(courseId => $courseId, commentId => $commentId);
};
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()
courseId = 789 # Long |  (default to null)
commentId = 789 # Long |  (default to null)

try:
    api_instance.delete_comment(courseId, commentId)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->deleteComment: %s\n" % e)
extern crate CommentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
courseId*
Long (int64)
Required
commentId*
Long (int64)
Required

Responses

getCommentById


/api/courses/{courseId}/comments/{commentId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/courses/{courseId}/comments/{commentId}"

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 courseId = 789; // Long | 
        Long commentId = 789; // Long | 

        try {
            Object result = apiInstance.getCommentById(courseId, commentId);
            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 courseId = new Long(); // Long | 
final Long commentId = new Long(); // Long | 

try {
    final result = await api_instance.getCommentById(courseId, commentId);
    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 courseId = 789; // Long | 
        Long commentId = 789; // Long | 

        try {
            Object result = apiInstance.getCommentById(courseId, commentId);
            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 *courseId = 789; //  (default to null)
Long *commentId = 789; //  (default to null)

[apiInstance getCommentByIdWith:courseId
    commentId:commentId
              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.CommentRestControllerApi()
var courseId = 789; // {Long} 
var commentId = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCommentById(courseId, commentId, 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 courseId = 789;  // Long |  (default to null)
            var commentId = 789;  // Long |  (default to null)

            try {
                Object result = apiInstance.getCommentById(courseId, commentId);
                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();
$courseId = 789; // Long | 
$commentId = 789; // Long | 

try {
    $result = $api_instance->getCommentById($courseId, $commentId);
    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 $courseId = 789; # Long | 
my $commentId = 789; # Long | 

eval {
    my $result = $api_instance->getCommentById(courseId => $courseId, commentId => $commentId);
    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()
courseId = 789 # Long |  (default to null)
commentId = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_comment_by_id(courseId, commentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getCommentById: %s\n" % e)
extern crate CommentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
courseId*
Long (int64)
Required
commentId*
Long (int64)
Required

Responses

getCommentsByCourse


/api/courses/{courseId}/comments

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/courses/{courseId}/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();
        Long courseId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CommentRestControllerApi;

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

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


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

[apiInstance getCommentsByCourseWith:courseId
              completionHandler: ^(array[CommentBasicDTO] 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 courseId = 789; // {Long} 

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

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

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

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

            try {
                array[CommentBasicDTO] result = apiInstance.getCommentsByCourse(courseId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.getCommentsByCourse: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->getCommentsByCourse($courseId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CommentRestControllerApi->getCommentsByCourse: ', $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 $courseId = 789; # Long | 

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

try:
    api_response = api_instance.get_comments_by_course(courseId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getCommentsByCourse: %s\n" % e)
extern crate CommentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
courseId*
Long (int64)
Required

Responses

getPaginatedComments


/api/courses/{courseId}/comments/paginated

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/courses/{courseId}/comments/paginated?pageable="

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 courseId = 789; // Long | 
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelCommentBasicDTO result = apiInstance.getPaginatedComments(courseId, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getPaginatedComments");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CommentRestControllerApi;

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

        try {
            PagedModelCommentBasicDTO result = apiInstance.getPaginatedComments(courseId, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CommentRestControllerApi#getPaginatedComments");
            e.printStackTrace();
        }
    }
}


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

[apiInstance getPaginatedCommentsWith:courseId
    pageable:pageable
              completionHandler: ^(PagedModelCommentBasicDTO 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 courseId = 789; // {Long} 
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                PagedModelCommentBasicDTO result = apiInstance.getPaginatedComments(courseId, pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CommentRestControllerApi.getPaginatedComments: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->getPaginatedComments($courseId, $pageable);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CommentRestControllerApi->getPaginatedComments: ', $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 $courseId = 789; # Long | 
my $pageable = ; # Pageable | 

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

try:
    api_response = api_instance.get_paginated_comments(courseId, pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CommentRestControllerApi->getPaginatedComments: %s\n" % e)
extern crate CommentRestControllerApi;

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

    let mut context = CommentRestControllerApi::Context::default();
    let result = client.getPaginatedComments(courseId, pageable, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
courseId*
Long (int64)
Required
Query parameters
Name Description
pageable*
Pageable
Required

Responses

CourseRestController

createCourse


/api/courses/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/courses/" \
 -d '{
  "image" : true,
  "numberOfUsers" : 1,
  "description" : "description",
  "id" : 6,
  "title" : "title",
  "tags" : [ "tags", "tags" ]
}'

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

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

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

        // Create an instance of the API class
        CourseRestControllerApi apiInstance = new CourseRestControllerApi();
        CourseBasicDTO courseBasicDTO = ; // CourseBasicDTO | 

        try {
            CourseBasicDTO result = apiInstance.createCourse(courseBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CourseRestControllerApi#createCourse");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CourseBasicDTO courseBasicDTO = new CourseBasicDTO(); // CourseBasicDTO | 

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


import org.openapitools.client.api.CourseRestControllerApi;

public class CourseRestControllerApiExample {
    public static void main(String[] args) {
        CourseRestControllerApi apiInstance = new CourseRestControllerApi();
        CourseBasicDTO courseBasicDTO = ; // CourseBasicDTO | 

        try {
            CourseBasicDTO result = apiInstance.createCourse(courseBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CourseRestControllerApi#createCourse");
            e.printStackTrace();
        }
    }
}


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

[apiInstance createCourseWith:courseBasicDTO
              completionHandler: ^(CourseBasicDTO 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.CourseRestControllerApi()
var courseBasicDTO = ; // {CourseBasicDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new CourseRestControllerApi();
            var courseBasicDTO = new CourseBasicDTO(); // CourseBasicDTO | 

            try {
                CourseBasicDTO result = apiInstance.createCourse(courseBasicDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CourseRestControllerApi.createCourse: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CourseRestControllerApi();
$courseBasicDTO = ; // CourseBasicDTO | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CourseRestControllerApi->new();
my $courseBasicDTO = WWW::OPenAPIClient::Object::CourseBasicDTO->new(); # CourseBasicDTO | 

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

try:
    api_response = api_instance.create_course(courseBasicDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->createCourse: %s\n" % e)
extern crate CourseRestControllerApi;

pub fn main() {
    let courseBasicDTO = ; // CourseBasicDTO

    let mut context = CourseRestControllerApi::Context::default();
    let result = client.createCourse(courseBasicDTO, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
courseBasicDTO *

Responses

createCourseImage


/api/courses/{id}/image

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/courses/{id}/image" \
 -d ''

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CourseRestControllerApi;

public class CourseRestControllerApiExample {
    public static void main(String[] args) {
        CourseRestControllerApi apiInstance = new CourseRestControllerApi();
        Long id = 789; // Long | 
        ReplaceCourseImageRequest replaceCourseImageRequest = ; // ReplaceCourseImageRequest | 

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


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

[apiInstance createCourseImageWith:id
    replaceCourseImageRequest:replaceCourseImageRequest
              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.CourseRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'replaceCourseImageRequest':  // {ReplaceCourseImageRequest} 
};

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.create_course_image(id, replaceCourseImageRequest=replaceCourseImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->createCourseImage: %s\n" % e)
extern crate CourseRestControllerApi;

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

    let mut context = CourseRestControllerApi::Context::default();
    let result = client.createCourseImage(id, replaceCourseImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
replaceCourseImageRequest

Responses

deleteCourse


/api/courses/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CourseRestControllerApi;

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

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


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

[apiInstance deleteCourseWith:id
              completionHandler: ^(CourseBasicDTO 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.CourseRestControllerApi()
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.deleteCourse(id, callback);

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

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

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

            try {
                CourseBasicDTO result = apiInstance.deleteCourse(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CourseRestControllerApi.deleteCourse: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.delete_course(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->deleteCourse: %s\n" % e)
extern crate CourseRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

deleteCourseImage


/api/courses/{id}/image

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CourseRestControllerApi;

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

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


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

[apiInstance deleteCourseImageWith: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.CourseRestControllerApi()
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.deleteCourseImage(id, callback);

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.delete_course_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->deleteCourseImage: %s\n" % e)
extern crate CourseRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

editCourse


/api/courses/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/courses/{id}" \
 -d '{
  "image" : true,
  "numberOfUsers" : 1,
  "description" : "description",
  "id" : 6,
  "title" : "title",
  "tags" : [ "tags", "tags" ]
}'

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

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

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

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

        try {
            CourseBasicDTO result = apiInstance.editCourse(id, courseBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CourseRestControllerApi#editCourse");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CourseRestControllerApi;

public class CourseRestControllerApiExample {
    public static void main(String[] args) {
        CourseRestControllerApi apiInstance = new CourseRestControllerApi();
        Long id = 789; // Long | 
        CourseBasicDTO courseBasicDTO = ; // CourseBasicDTO | 

        try {
            CourseBasicDTO result = apiInstance.editCourse(id, courseBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CourseRestControllerApi#editCourse");
            e.printStackTrace();
        }
    }
}


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

[apiInstance editCourseWith:id
    courseBasicDTO:courseBasicDTO
              completionHandler: ^(CourseBasicDTO 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.CourseRestControllerApi()
var id = 789; // {Long} 
var courseBasicDTO = ; // {CourseBasicDTO} 

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

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

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

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

            try {
                CourseBasicDTO result = apiInstance.editCourse(id, courseBasicDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CourseRestControllerApi.editCourse: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.edit_course(id, courseBasicDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->editCourse: %s\n" % e)
extern crate CourseRestControllerApi;

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

    let mut context = CourseRestControllerApi::Context::default();
    let result = client.editCourse(id, courseBasicDTO, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
courseBasicDTO *

Responses

getChartData


/api/courses/chartdata

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/courses/chartdata"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.CourseRestControllerApi;

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

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


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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_chart_data()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->getChartData: %s\n" % e)
extern crate CourseRestControllerApi;

pub fn main() {

    let mut context = CourseRestControllerApi::Context::default();
    let result = client.getChartData(&context).wait();

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

Scopes

Parameters

Responses

getCourse


/api/courses/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CourseRestControllerApi;

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

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


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

[apiInstance getCourseWith:id
              completionHandler: ^(CourseBasicDTO 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.CourseRestControllerApi()
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.getCourse(id, callback);

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

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

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

            try {
                CourseBasicDTO result = apiInstance.getCourse(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CourseRestControllerApi.getCourse: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.get_course(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->getCourse: %s\n" % e)
extern crate CourseRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getCourseImage


/api/courses/{id}/image

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CourseRestControllerApi;

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

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


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

[apiInstance getCourseImageWith: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.CourseRestControllerApi()
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.getCourseImage(id, callback);

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_course_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->getCourseImage: %s\n" % e)
extern crate CourseRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getCourses


/api/courses/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/courses/?page=56&size=56&sortBy=sortBy_example"

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

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

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

        // Create an instance of the API class
        CourseRestControllerApi apiInstance = new CourseRestControllerApi();
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 
        String sortBy = sortBy_example; // String | 

        try {
            PagedModelCourseBasicDTO result = apiInstance.getCourses(page, size, sortBy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CourseRestControllerApi#getCourses");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | 
final Integer size = new Integer(); // Integer | 
final String sortBy = new String(); // String | 

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


import org.openapitools.client.api.CourseRestControllerApi;

public class CourseRestControllerApiExample {
    public static void main(String[] args) {
        CourseRestControllerApi apiInstance = new CourseRestControllerApi();
        Integer page = 56; // Integer | 
        Integer size = 56; // Integer | 
        String sortBy = sortBy_example; // String | 

        try {
            PagedModelCourseBasicDTO result = apiInstance.getCourses(page, size, sortBy);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CourseRestControllerApi#getCourses");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
CourseRestControllerApi *apiInstance = [[CourseRestControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to 0)
Integer *size = 56; //  (optional) (default to 10)
String *sortBy = sortBy_example; //  (optional) (default to id)

[apiInstance getCoursesWith:page
    size:size
    sortBy:sortBy
              completionHandler: ^(PagedModelCourseBasicDTO 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.CourseRestControllerApi()
var opts = {
  'page': 56, // {Integer} 
  'size': 56, // {Integer} 
  'sortBy': sortBy_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new CourseRestControllerApi();
            var page = 56;  // Integer |  (optional)  (default to 0)
            var size = 56;  // Integer |  (optional)  (default to 10)
            var sortBy = sortBy_example;  // String |  (optional)  (default to id)

            try {
                PagedModelCourseBasicDTO result = apiInstance.getCourses(page, size, sortBy);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CourseRestControllerApi.getCourses: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CourseRestControllerApi();
$page = 56; // Integer | 
$size = 56; // Integer | 
$sortBy = sortBy_example; // String | 

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

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

eval {
    my $result = $api_instance->getCourses(page => $page, size => $size, sortBy => $sortBy);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CourseRestControllerApi->getCourses: $@\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.CourseRestControllerApi()
page = 56 # Integer |  (optional) (default to 0)
size = 56 # Integer |  (optional) (default to 10)
sortBy = sortBy_example # String |  (optional) (default to id)

try:
    api_response = api_instance.get_courses(page=page, size=size, sortBy=sortBy)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->getCourses: %s\n" % e)
extern crate CourseRestControllerApi;

pub fn main() {
    let page = 56; // Integer
    let size = 56; // Integer
    let sortBy = sortBy_example; // String

    let mut context = CourseRestControllerApi::Context::default();
    let result = client.getCourses(page, size, sortBy, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)
size
Integer (int32)
sortBy
String

Responses

replaceCourseImage


/api/courses/{id}/image

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/courses/{id}/image" \
 -d ''

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.CourseRestControllerApi;

public class CourseRestControllerApiExample {
    public static void main(String[] args) {
        CourseRestControllerApi apiInstance = new CourseRestControllerApi();
        Long id = 789; // Long | 
        ReplaceCourseImageRequest replaceCourseImageRequest = ; // ReplaceCourseImageRequest | 

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


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

[apiInstance replaceCourseImageWith:id
    replaceCourseImageRequest:replaceCourseImageRequest
              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.CourseRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'replaceCourseImageRequest':  // {ReplaceCourseImageRequest} 
};

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.replace_course_image(id, replaceCourseImageRequest=replaceCourseImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CourseRestControllerApi->replaceCourseImage: %s\n" % e)
extern crate CourseRestControllerApi;

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

    let mut context = CourseRestControllerApi::Context::default();
    let result = client.replaceCourseImage(id, replaceCourseImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
replaceCourseImageRequest

Responses

LoginController

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.LoginControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.LoginControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses

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.LoginControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.LoginControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var loginRequest = ; // {LoginRequest} 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Body parameters
Name Description
loginRequest *

Responses

refreshToken


/api/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.LoginControllerApi;

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.LoginControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var opts = {
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginControllerApi()
refreshToken = refreshToken_example # String |  (optional) (default to null)

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

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

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

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

Scopes

Parameters

Responses

MaterialRestController

deleteFile


/api/materials/courses/{courseId}/materials/{materialId}/

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/materials/courses/{courseId}/materials/{materialId}/"

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

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

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

        // Create an instance of the API class
        MaterialRestControllerApi apiInstance = new MaterialRestControllerApi();
        Long courseId = 789; // Long | 
        Long materialId = 789; // Long | 

        try {
            apiInstance.deleteFile(courseId, materialId);
        } catch (ApiException e) {
            System.err.println("Exception when calling MaterialRestControllerApi#deleteFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long courseId = new Long(); // Long | 
final Long materialId = new Long(); // Long | 

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


import org.openapitools.client.api.MaterialRestControllerApi;

public class MaterialRestControllerApiExample {
    public static void main(String[] args) {
        MaterialRestControllerApi apiInstance = new MaterialRestControllerApi();
        Long courseId = 789; // Long | 
        Long materialId = 789; // Long | 

        try {
            apiInstance.deleteFile(courseId, materialId);
        } catch (ApiException e) {
            System.err.println("Exception when calling MaterialRestControllerApi#deleteFile");
            e.printStackTrace();
        }
    }
}


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

[apiInstance deleteFileWith:courseId
    materialId:materialId
              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.MaterialRestControllerApi()
var courseId = 789; // {Long} 
var materialId = 789; // {Long} 

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

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

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

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

            try {
                apiInstance.deleteFile(courseId, materialId);
            } catch (Exception e) {
                Debug.Print("Exception when calling MaterialRestControllerApi.deleteFile: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_instance.delete_file(courseId, materialId)
except ApiException as e:
    print("Exception when calling MaterialRestControllerApi->deleteFile: %s\n" % e)
extern crate MaterialRestControllerApi;

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

    let mut context = MaterialRestControllerApi::Context::default();
    let result = client.deleteFile(courseId, materialId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
courseId*
Long (int64)
Required
materialId*
Long (int64)
Required

Responses

downloadFile


/api/materials/courses/{courseId}/materials/{materialId}/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/materials/courses/{courseId}/materials/{materialId}/"

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

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

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

        // Create an instance of the API class
        MaterialRestControllerApi apiInstance = new MaterialRestControllerApi();
        Long courseId = 789; // Long | 
        Long materialId = 789; // Long | 

        try {
            byte[] result = apiInstance.downloadFile(courseId, materialId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MaterialRestControllerApi#downloadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long courseId = new Long(); // Long | 
final Long materialId = new Long(); // Long | 

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


import org.openapitools.client.api.MaterialRestControllerApi;

public class MaterialRestControllerApiExample {
    public static void main(String[] args) {
        MaterialRestControllerApi apiInstance = new MaterialRestControllerApi();
        Long courseId = 789; // Long | 
        Long materialId = 789; // Long | 

        try {
            byte[] result = apiInstance.downloadFile(courseId, materialId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MaterialRestControllerApi#downloadFile");
            e.printStackTrace();
        }
    }
}


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

[apiInstance downloadFileWith:courseId
    materialId:materialId
              completionHandler: ^(byte[] 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.MaterialRestControllerApi()
var courseId = 789; // {Long} 
var materialId = 789; // {Long} 

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

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

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

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

            try {
                byte[] result = apiInstance.downloadFile(courseId, materialId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MaterialRestControllerApi.downloadFile: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.download_file(courseId, materialId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MaterialRestControllerApi->downloadFile: %s\n" % e)
extern crate MaterialRestControllerApi;

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

    let mut context = MaterialRestControllerApi::Context::default();
    let result = client.downloadFile(courseId, materialId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
courseId*
Long (int64)
Required
materialId*
Long (int64)
Required

Responses

loadMoreMaterials


/api/materials/courses/{courseId}/load

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/materials/courses/{courseId}/load?pageable="

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

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

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

        // Create an instance of the API class
        MaterialRestControllerApi apiInstance = new MaterialRestControllerApi();
        Long courseId = 789; // Long | 
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelMaterialBasicDTO result = apiInstance.loadMoreMaterials(courseId, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MaterialRestControllerApi#loadMoreMaterials");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.MaterialRestControllerApi;

public class MaterialRestControllerApiExample {
    public static void main(String[] args) {
        MaterialRestControllerApi apiInstance = new MaterialRestControllerApi();
        Long courseId = 789; // Long | 
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelMaterialBasicDTO result = apiInstance.loadMoreMaterials(courseId, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MaterialRestControllerApi#loadMoreMaterials");
            e.printStackTrace();
        }
    }
}


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

[apiInstance loadMoreMaterialsWith:courseId
    pageable:pageable
              completionHandler: ^(PagedModelMaterialBasicDTO 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.MaterialRestControllerApi()
var courseId = 789; // {Long} 
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                PagedModelMaterialBasicDTO result = apiInstance.loadMoreMaterials(courseId, pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MaterialRestControllerApi.loadMoreMaterials: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.load_more_materials(courseId, pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MaterialRestControllerApi->loadMoreMaterials: %s\n" % e)
extern crate MaterialRestControllerApi;

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

    let mut context = MaterialRestControllerApi::Context::default();
    let result = client.loadMoreMaterials(courseId, pageable, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
courseId*
Long (int64)
Required
Query parameters
Name Description
pageable*
Pageable
Required

Responses

uploadFile


/api/materials/courses/{id}/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/materials/courses/{id}/" \
 -d ''

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

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

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

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

        try {
            MaterialBasicDTO result = apiInstance.uploadFile(id, uploadFileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MaterialRestControllerApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.MaterialRestControllerApi;

public class MaterialRestControllerApiExample {
    public static void main(String[] args) {
        MaterialRestControllerApi apiInstance = new MaterialRestControllerApi();
        Long id = 789; // Long | 
        UploadFileRequest uploadFileRequest = ; // UploadFileRequest | 

        try {
            MaterialBasicDTO result = apiInstance.uploadFile(id, uploadFileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MaterialRestControllerApi#uploadFile");
            e.printStackTrace();
        }
    }
}


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

[apiInstance uploadFileWith:id
    uploadFileRequest:uploadFileRequest
              completionHandler: ^(MaterialBasicDTO 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.MaterialRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'uploadFileRequest':  // {UploadFileRequest} 
};

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

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

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

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

            try {
                MaterialBasicDTO result = apiInstance.uploadFile(id, uploadFileRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MaterialRestControllerApi.uploadFile: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.upload_file(id, uploadFileRequest=uploadFileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MaterialRestControllerApi->uploadFile: %s\n" % e)
extern crate MaterialRestControllerApi;

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

    let mut context = MaterialRestControllerApi::Context::default();
    let result = client.uploadFile(id, uploadFileRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
uploadFileRequest

Responses

UserRestController

deleteUser


/api/users/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.UserRestControllerApi;

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

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


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

[apiInstance deleteUserWith:id
              completionHandler: ^(UserNoImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                UserNoImageDTO result = apiInstance.deleteUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

editUserProfile


/api/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/users/{id}" \
 -d '{
  "courses" : [ {
    "image" : true,
    "numberOfUsers" : 1,
    "description" : "description",
    "id" : 6,
    "title" : "title",
    "tags" : [ "tags", "tags" ]
  }, {
    "image" : true,
    "numberOfUsers" : 1,
    "description" : "description",
    "id" : 6,
    "title" : "title",
    "tags" : [ "tags", "tags" ]
  } ],
  "password" : "password",
  "comments" : [ {
    "createdDate" : "2000-01-23",
    "id" : 5,
    "text" : "text"
  }, {
    "createdDate" : "2000-01-23",
    "id" : 5,
    "text" : "text"
  } ],
  "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 | 
        UserNoImageDTO userNoImageDTO = ; // UserNoImageDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.editUserProfile(id, userNoImageDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->editUserProfile: $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 | 
        UserNoImageDTO userNoImageDTO = ; // UserNoImageDTO | 

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


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

[apiInstance editUserProfileWith:id
    userNoImageDTO:userNoImageDTO
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                'String' result = apiInstance.editUserProfile(id, userNoImageDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.editUserProfile: " + 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 | 
$userNoImageDTO = ; // UserNoImageDTO | 

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

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

try:
    api_response = api_instance.edit_user_profile(id, userNoImageDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->editUserProfile: %s\n" % e)
extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
userNoImageDTO *

Responses

getProfileImage


/api/users/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/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.getProfileImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getProfileImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.getProfileImage(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getProfileImage: $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.getProfileImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getProfileImage");
            e.printStackTrace();
        }
    }
}


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

[apiInstance getProfileImageWith: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.getProfileImage(id, callback);

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

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

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

            try {
                Object result = apiInstance.getProfileImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getProfileImage: " + 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->getProfileImage($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getProfileImage: ', $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->getProfileImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getProfileImage: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

registerUser


/api/users/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/users/" \
 -d '{
  "courses" : [ {
    "image" : true,
    "numberOfUsers" : 1,
    "description" : "description",
    "id" : 6,
    "title" : "title",
    "tags" : [ "tags", "tags" ]
  }, {
    "image" : true,
    "numberOfUsers" : 1,
    "description" : "description",
    "id" : 6,
    "title" : "title",
    "tags" : [ "tags", "tags" ]
  } ],
  "password" : "password",
  "comments" : [ {
    "createdDate" : "2000-01-23",
    "id" : 5,
    "text" : "text"
  }, {
    "createdDate" : "2000-01-23",
    "id" : 5,
    "text" : "text"
  } ],
  "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();
        UserNoImageDTO userNoImageDTO = ; // UserNoImageDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserNoImageDTO userNoImageDTO = new UserNoImageDTO(); // UserNoImageDTO | 

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


import org.openapitools.client.api.UserRestControllerApi;

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

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


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

[apiInstance registerUserWith:userNoImageDTO
              completionHandler: ^(UserNoImageDTO 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 userNoImageDTO = ; // {UserNoImageDTO} 

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

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

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

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

            try {
                UserNoImageDTO result = apiInstance.registerUser(userNoImageDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.registerUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

try:
    api_response = api_instance.register_user(userNoImageDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->registerUser: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let userNoImageDTO = ; // UserNoImageDTO

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

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

Scopes

Parameters

Body parameters
Name Description
userNoImageDTO *

Responses

showUserProfile


/api/users/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.showUserProfile(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->showUserProfile: $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 {
            UserNoImageDTO result = apiInstance.showUserProfile(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#showUserProfile");
            e.printStackTrace();
        }
    }
}


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

[apiInstance showUserProfileWith:id
              completionHandler: ^(UserNoImageDTO 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.showUserProfile(id, callback);

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

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

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

            try {
                UserNoImageDTO result = apiInstance.showUserProfile(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.showUserProfile: " + 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->showUserProfile($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->showUserProfile: ', $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->showUserProfile(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->showUserProfile: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

showUsers


/api/users/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/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 {
            PagedModelUserNoImageDTO result = apiInstance.showUsers(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#showUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.showUsers(pageable);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->showUsers: $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 {
            PagedModelUserNoImageDTO result = apiInstance.showUsers(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#showUsers");
            e.printStackTrace();
        }
    }
}


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

[apiInstance showUsersWith:pageable
              completionHandler: ^(PagedModelUserNoImageDTO 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.showUsers(pageable, callback);

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

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

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

            try {
                PagedModelUserNoImageDTO result = apiInstance.showUsers(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.showUsers: " + 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->showUsers($pageable);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->showUsers: ', $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->showUsers(pageable => $pageable);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->showUsers: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
pageable =  # Pageable |  (default to null)

try:
    api_response = api_instance.show_users(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->showUsers: %s\n" % e)
extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters
Name Description
pageable*
Pageable
Required

Responses