OpenAPI definition

AdminDashboardRestController

ban

If the user is a admin, he can ban another user according to his ID


/api/ban/{id}

Usage and SDK Samples

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

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

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

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

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

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

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


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

// If the user is a admin, he can ban another user according to his ID
[apiInstance banWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // If the user is a admin, he can ban another user according to his ID
                apiInstance.ban(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminDashboardRestControllerApi.ban: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # If the user is a admin, he can ban another user according to his ID
    api_instance.ban(id)
except ApiException as e:
    print("Exception when calling AdminDashboardRestControllerApi->ban: %s\n" % e)
extern crate AdminDashboardRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 404 - User ID not found

Status: 200 - User Banned


getNewAccountStatistics

If the user is a admin, he can get the statistics of new accounts created in the last 5 days whit new accounts


/api/statistics

Usage and SDK Samples

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

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

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

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

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

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

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


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

// If the user is a admin, he can get the statistics of new accounts created in the last 5 days whit new accounts
[apiInstance getNewAccountStatisticsWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

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

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

            try {
                // If the user is a admin, he can get the statistics of new accounts created in the last 5 days whit new accounts
                apiInstance.getNewAccountStatistics();
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminDashboardRestControllerApi.getNewAccountStatistics: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # If the user is a admin, he can get the statistics of new accounts created in the last 5 days whit new accounts
    api_instance.get_new_account_statistics()
except ApiException as e:
    print("Exception when calling AdminDashboardRestControllerApi->getNewAccountStatistics: %s\n" % e)
extern crate AdminDashboardRestControllerApi;

pub fn main() {

    let mut context = AdminDashboardRestControllerApi::Context::default();
    let result = client.getNewAccountStatistics(&context).wait();

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

Scopes

Parameters

Responses

Status: 403 - No permission

Status: 200 - Statistics shown


unban

If the user is a admin, he can unban another user according to his ID


/api/unban/{id}

Usage and SDK Samples

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

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

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

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

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

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

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


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

// If the user is a admin, he can unban another user according to his ID
[apiInstance unbanWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // If the user is a admin, he can unban another user according to his ID
                apiInstance.unban(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminDashboardRestControllerApi.unban: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # If the user is a admin, he can unban another user according to his ID
    api_instance.unban(id)
except ApiException as e:
    print("Exception when calling AdminDashboardRestControllerApi->unban: %s\n" % e)
extern crate AdminDashboardRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 404 - User ID not found

Status: 200 - User Banned


unverify

If the user is a admin, he can unverify another user according to his ID


/api/unverify/{id}

Usage and SDK Samples

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

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

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

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

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

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

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


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

// If the user is a admin, he can unverify another user according to his ID
[apiInstance unverifyWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // If the user is a admin, he can unverify another user according to his ID
                apiInstance.unverify(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminDashboardRestControllerApi.unverify: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # If the user is a admin, he can unverify another user according to his ID
    api_instance.unverify(id)
except ApiException as e:
    print("Exception when calling AdminDashboardRestControllerApi->unverify: %s\n" % e)
extern crate AdminDashboardRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 404 - User ID not found

Status: 200 - User Banned


verify

If the user is a admin, he can verify another user according to his ID


/api/verify/{id}

Usage and SDK Samples

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

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

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

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

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

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

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


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

// If the user is a admin, he can verify another user according to his ID
[apiInstance verifyWith:id
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // If the user is a admin, he can verify another user according to his ID
                apiInstance.verify(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminDashboardRestControllerApi.verify: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # If the user is a admin, he can verify another user according to his ID
    api_instance.verify(id)
except ApiException as e:
    print("Exception when calling AdminDashboardRestControllerApi->verify: %s\n" % e)
extern crate AdminDashboardRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 404 - User ID not found

Status: 200 - User Banned


LoginRestController

logOut

Log a user out of the application


/api/logout

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Log a user out of the application
[apiInstance logOutWithCompletionHandler: 
              ^(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.LoginRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.logOut(callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

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

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

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

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

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

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses

Status: 200 - Log Out successful

Status: 400 - invalid request


login

Check the credentials of a user and let them in if they are correct


/api/login

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Check the credentials of a user and let them in if they are correct
[apiInstance loginWith:loginRequest
    accessToken:accessToken
    refreshToken:refreshToken
              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.LoginRestControllerApi()
var loginRequest = ; // {LoginRequest} 
var opts = {
  'accessToken': accessToken_example, // {String} 
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

            try {
                // Check the credentials of a user and let them in if they are correct
                Object result = apiInstance.login(loginRequest, accessToken, refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.login: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    # Check the credentials of a user and let them in if they are correct
    api_response = api_instance.login(loginRequest, accessToken=accessToken, refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginRestControllerApi->login: %s\n" % e)
extern crate LoginRestControllerApi;

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

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

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

Scopes

Parameters

Body parameters
Name Description
loginRequest *

{
username:
string
password:
string

Responses

Status: 400 - invalid credentials

Status: 200 - Log In successful


refreshToken

Refresh the content of a page


/api/refresh

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Refresh the content of a page
[apiInstance refreshTokenWith:refreshToken
              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.LoginRestControllerApi()
var opts = {
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

            try {
                // Refresh the content of a page
                Object result = apiInstance.refreshToken(refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginRestControllerApi.refreshToken: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    # Refresh the content of a page
    api_response = api_instance.refresh_token(refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginRestControllerApi->refreshToken: %s\n" % e)
extern crate LoginRestControllerApi;

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

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

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

Scopes

Parameters

Responses

Status: 200 - Page has been successfully refreshed

Status: 404 - URL not found


ResetPasswordRestController

processForgotPassword

Send a mail to reset a user's password in case it was forgotten


/api/forgot-password

Usage and SDK Samples

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

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

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

        // Create an instance of the API class
        ResetPasswordRestControllerApi apiInstance = new ResetPasswordRestControllerApi();
        ForgotPasswordRequest forgotPasswordRequest = ; // ForgotPasswordRequest | 

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

public class ResetPasswordRestControllerApiExample {
    public static void main(String[] args) {
        ResetPasswordRestControllerApi apiInstance = new ResetPasswordRestControllerApi();
        ForgotPasswordRequest forgotPasswordRequest = ; // ForgotPasswordRequest | 

        try {
            TweetInformation result = apiInstance.processForgotPassword(forgotPasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResetPasswordRestControllerApi#processForgotPassword");
            e.printStackTrace();
        }
    }
}


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

// Send a mail to reset a user's password in case it was forgotten
[apiInstance processForgotPasswordWith:forgotPasswordRequest
              completionHandler: ^(TweetInformation 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.ResetPasswordRestControllerApi()
var forgotPasswordRequest = ; // {ForgotPasswordRequest} 

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

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

            // Create an instance of the API class
            var apiInstance = new ResetPasswordRestControllerApi();
            var forgotPasswordRequest = new ForgotPasswordRequest(); // ForgotPasswordRequest | 

            try {
                // Send a mail to reset a user's password in case it was forgotten
                TweetInformation result = apiInstance.processForgotPassword(forgotPasswordRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResetPasswordRestControllerApi.processForgotPassword: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResetPasswordRestControllerApi();
$forgotPasswordRequest = ; // ForgotPasswordRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResetPasswordRestControllerApi->new();
my $forgotPasswordRequest = WWW::OPenAPIClient::Object::ForgotPasswordRequest->new(); # ForgotPasswordRequest | 

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

try:
    # Send a mail to reset a user's password in case it was forgotten
    api_response = api_instance.process_forgot_password(forgotPasswordRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResetPasswordRestControllerApi->processForgotPassword: %s\n" % e)
extern crate ResetPasswordRestControllerApi;

pub fn main() {
    let forgotPasswordRequest = ; // ForgotPasswordRequest

    let mut context = ResetPasswordRestControllerApi::Context::default();
    let result = client.processForgotPassword(forgotPasswordRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
forgotPasswordRequest *

{
email:
string

Responses

Status: 404 - Mail not found

Status: 200 - Link successfully send


processResetPassword

Change the user's password for a new one


/api/reset-password

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/reset-password?passwordToken=passwordToken_example" \
 -d '{
  "password" : "password"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ResetPasswordRestControllerApi;

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

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

        // Create an instance of the API class
        ResetPasswordRestControllerApi apiInstance = new ResetPasswordRestControllerApi();
        String passwordToken = passwordToken_example; // String | 
        ResetPasswordRequest resetPasswordRequest = ; // ResetPasswordRequest | 

        try {
            TweetInformation result = apiInstance.processResetPassword(passwordToken, resetPasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResetPasswordRestControllerApi#processResetPassword");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ResetPasswordRestControllerApi;

public class ResetPasswordRestControllerApiExample {
    public static void main(String[] args) {
        ResetPasswordRestControllerApi apiInstance = new ResetPasswordRestControllerApi();
        String passwordToken = passwordToken_example; // String | 
        ResetPasswordRequest resetPasswordRequest = ; // ResetPasswordRequest | 

        try {
            TweetInformation result = apiInstance.processResetPassword(passwordToken, resetPasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ResetPasswordRestControllerApi#processResetPassword");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ResetPasswordRestControllerApi *apiInstance = [[ResetPasswordRestControllerApi alloc] init];
String *passwordToken = passwordToken_example; //  (default to null)
ResetPasswordRequest *resetPasswordRequest = ; // 

// Change the user's password for a new one
[apiInstance processResetPasswordWith:passwordToken
    resetPasswordRequest:resetPasswordRequest
              completionHandler: ^(TweetInformation 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.ResetPasswordRestControllerApi()
var passwordToken = passwordToken_example; // {String} 
var resetPasswordRequest = ; // {ResetPasswordRequest} 

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

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

            // Create an instance of the API class
            var apiInstance = new ResetPasswordRestControllerApi();
            var passwordToken = passwordToken_example;  // String |  (default to null)
            var resetPasswordRequest = new ResetPasswordRequest(); // ResetPasswordRequest | 

            try {
                // Change the user's password for a new one
                TweetInformation result = apiInstance.processResetPassword(passwordToken, resetPasswordRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ResetPasswordRestControllerApi.processResetPassword: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ResetPasswordRestControllerApi();
$passwordToken = passwordToken_example; // String | 
$resetPasswordRequest = ; // ResetPasswordRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ResetPasswordRestControllerApi->new();
my $passwordToken = passwordToken_example; # String | 
my $resetPasswordRequest = WWW::OPenAPIClient::Object::ResetPasswordRequest->new(); # ResetPasswordRequest | 

eval {
    my $result = $api_instance->processResetPassword(passwordToken => $passwordToken, resetPasswordRequest => $resetPasswordRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ResetPasswordRestControllerApi->processResetPassword: $@\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.ResetPasswordRestControllerApi()
passwordToken = passwordToken_example # String |  (default to null)
resetPasswordRequest =  # ResetPasswordRequest | 

try:
    # Change the user's password for a new one
    api_response = api_instance.process_reset_password(passwordToken, resetPasswordRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ResetPasswordRestControllerApi->processResetPassword: %s\n" % e)
extern crate ResetPasswordRestControllerApi;

pub fn main() {
    let passwordToken = passwordToken_example; // String
    let resetPasswordRequest = ; // ResetPasswordRequest

    let mut context = ResetPasswordRestControllerApi::Context::default();
    let result = client.processResetPassword(passwordToken, resetPasswordRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
resetPasswordRequest *

{
password:
string
Query parameters
Name Description
passwordToken*
String
Required

Responses

Status: 200 - Password has been reset

Status: 404 - Token not found


RestHashtagController

getSomeTrends

Get some of the current trends


/api/hashtags/trends

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/hashtags/trends?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestHashtagControllerApi;

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

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

        // Create an instance of the API class
        RestHashtagControllerApi apiInstance = new RestHashtagControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            Trend result = apiInstance.getSomeTrends(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestHashtagControllerApi#getSomeTrends");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestHashtagControllerApi;

public class RestHashtagControllerApiExample {
    public static void main(String[] args) {
        RestHashtagControllerApi apiInstance = new RestHashtagControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            Trend result = apiInstance.getSomeTrends(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestHashtagControllerApi#getSomeTrends");
            e.printStackTrace();
        }
    }
}


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

// Get some of the current trends
[apiInstance getSomeTrendsWith:from
    size:size
              completionHandler: ^(Trend 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.RestHashtagControllerApi()
var from = 56; // {Integer} 
var size = 56; // {Integer} 

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

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

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

            try {
                // Get some of the current trends
                Trend result = apiInstance.getSomeTrends(from, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestHashtagControllerApi.getSomeTrends: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get some of the current trends
    api_response = api_instance.get_some_trends(from, size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestHashtagControllerApi->getSomeTrends: %s\n" % e)
extern crate RestHashtagControllerApi;

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

    let mut context = RestHashtagControllerApi::Context::default();
    let result = client.getSomeTrends(from, size, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 200 - Trends obtained

{
hashtag:
string
numTweets:
integer (int32)

Status: 202 - Trends not found


getSomeTweetsAssociatedToAHashtag

Get some tweets associated to a hashtag


/api/hashtags/explore/{hashtag}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/hashtags/explore/{hashtag}?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestHashtagControllerApi;

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

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

        // Create an instance of the API class
        RestHashtagControllerApi apiInstance = new RestHashtagControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 
        String hashtag = hashtag_example; // String | 

        try {
            TweetInformation_Basic result = apiInstance.getSomeTweetsAssociatedToAHashtag(from, size, hashtag);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestHashtagControllerApi#getSomeTweetsAssociatedToAHashtag");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestHashtagControllerApi;

public class RestHashtagControllerApiExample {
    public static void main(String[] args) {
        RestHashtagControllerApi apiInstance = new RestHashtagControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 
        String hashtag = hashtag_example; // String | 

        try {
            TweetInformation_Basic result = apiInstance.getSomeTweetsAssociatedToAHashtag(from, size, hashtag);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestHashtagControllerApi#getSomeTweetsAssociatedToAHashtag");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestHashtagControllerApi *apiInstance = [[RestHashtagControllerApi alloc] init];
Integer *from = 56; //  (default to null)
Integer *size = 56; //  (default to null)
String *hashtag = hashtag_example; //  (default to null)

// Get some tweets associated to a hashtag
[apiInstance getSomeTweetsAssociatedToAHashtagWith:from
    size:size
    hashtag:hashtag
              completionHandler: ^(TweetInformation_Basic 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.RestHashtagControllerApi()
var from = 56; // {Integer} 
var size = 56; // {Integer} 
var hashtag = hashtag_example; // {String} 

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

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

            // Create an instance of the API class
            var apiInstance = new RestHashtagControllerApi();
            var from = 56;  // Integer |  (default to null)
            var size = 56;  // Integer |  (default to null)
            var hashtag = hashtag_example;  // String |  (default to null)

            try {
                // Get some tweets associated to a hashtag
                TweetInformation_Basic result = apiInstance.getSomeTweetsAssociatedToAHashtag(from, size, hashtag);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestHashtagControllerApi.getSomeTweetsAssociatedToAHashtag: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestHashtagControllerApi();
$from = 56; // Integer | 
$size = 56; // Integer | 
$hashtag = hashtag_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestHashtagControllerApi->new();
my $from = 56; # Integer | 
my $size = 56; # Integer | 
my $hashtag = hashtag_example; # String | 

eval {
    my $result = $api_instance->getSomeTweetsAssociatedToAHashtag(from => $from, size => $size, hashtag => $hashtag);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestHashtagControllerApi->getSomeTweetsAssociatedToAHashtag: $@\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.RestHashtagControllerApi()
from = 56 # Integer |  (default to null)
size = 56 # Integer |  (default to null)
hashtag = hashtag_example # String |  (default to null)

try:
    # Get some tweets associated to a hashtag
    api_response = api_instance.get_some_tweets_associated_to_a_hashtag(from, size, hashtag)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestHashtagControllerApi->getSomeTweetsAssociatedToAHashtag: %s\n" % e)
extern crate RestHashtagControllerApi;

pub fn main() {
    let from = 56; // Integer
    let size = 56; // Integer
    let hashtag = hashtag_example; // String

    let mut context = RestHashtagControllerApi::Context::default();
    let result = client.getSomeTweetsAssociatedToAHashtag(from, size, hashtag, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
hashtag*
String
Required
Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 200 - Tweets obtained

Status: 202 - Tweets not found


RestImageController

downloadBannerPic

Get the banner pic associated to a user


/api/images/{id}/banner-pic

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Get the banner pic associated to a user
[apiInstance downloadBannerPicWith: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.RestImageControllerApi()
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.downloadBannerPic(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Get the banner pic associated to a user
                Object result = apiInstance.downloadBannerPic(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestImageControllerApi.downloadBannerPic: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get the banner pic associated to a user
    api_response = api_instance.download_banner_pic(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestImageControllerApi->downloadBannerPic: %s\n" % e)
extern crate RestImageControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - Banner pic obtained

Status: 202 - Banner pic not found


downloadProfilePic

Get the profile pic associated to a user


/api/images/{id}/profile-pic

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Get the profile pic associated to a user
[apiInstance downloadProfilePicWith: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.RestImageControllerApi()
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.downloadProfilePic(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Get the profile pic associated to a user
                Object result = apiInstance.downloadProfilePic(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestImageControllerApi.downloadProfilePic: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get the profile pic associated to a user
    api_response = api_instance.download_profile_pic(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestImageControllerApi->downloadProfilePic: %s\n" % e)
extern crate RestImageControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - Profile pic obtained

Status: 202 - Profile pic not found


downloadTweetImage1

Get the first media associated to a tweet


/api/images/{id}/tweet-image1

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Get the first media associated to a tweet
[apiInstance downloadTweetImage1With: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.RestImageControllerApi()
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.downloadTweetImage1(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Get the first media associated to a tweet
                Object result = apiInstance.downloadTweetImage1(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestImageControllerApi.downloadTweetImage1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get the first media associated to a tweet
    api_response = api_instance.download_tweet_image1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestImageControllerApi->downloadTweetImage1: %s\n" % e)
extern crate RestImageControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 202 - First media not found

Status: 200 - First media obtained


downloadTweetImage2

Get the second media associated to a tweet


/api/images/{id}/tweet-image2

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Get the second media associated to a tweet
[apiInstance downloadTweetImage2With: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.RestImageControllerApi()
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.downloadTweetImage2(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Get the second media associated to a tweet
                Object result = apiInstance.downloadTweetImage2(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestImageControllerApi.downloadTweetImage2: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get the second media associated to a tweet
    api_response = api_instance.download_tweet_image2(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestImageControllerApi->downloadTweetImage2: %s\n" % e)
extern crate RestImageControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - Second media obtained

Status: 202 - Second media not found


downloadTweetImage3

Get the third media associated to a tweet


/api/images/{id}/tweet-image3

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Get the third media associated to a tweet
[apiInstance downloadTweetImage3With: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.RestImageControllerApi()
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.downloadTweetImage3(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Get the third media associated to a tweet
                Object result = apiInstance.downloadTweetImage3(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestImageControllerApi.downloadTweetImage3: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get the third media associated to a tweet
    api_response = api_instance.download_tweet_image3(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestImageControllerApi->downloadTweetImage3: %s\n" % e)
extern crate RestImageControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 202 - Third media not found

Status: 200 - Third media obtained


downloadTweetImage4

Get the fourth media associated to a tweet


/api/images/{id}/tweet-image4

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Get the fourth media associated to a tweet
[apiInstance downloadTweetImage4With: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.RestImageControllerApi()
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.downloadTweetImage4(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Get the fourth media associated to a tweet
                Object result = apiInstance.downloadTweetImage4(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestImageControllerApi.downloadTweetImage4: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get the fourth media associated to a tweet
    api_response = api_instance.download_tweet_image4(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestImageControllerApi->downloadTweetImage4: %s\n" % e)
extern crate RestImageControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 202 - Fourth media not found

Status: 200 - Fourth media obtained


RestNotificationController

deleteNotification

Deletes a notification to a user


/api/notifications/delete-notification

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/notifications/delete-notification?idTweet=789" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestNotificationControllerApi;

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

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

        // Create an instance of the API class
        RestNotificationControllerApi apiInstance = new RestNotificationControllerApi();
        Long idTweet = 789; // Long | 
        String body = body_example; // String | 

        try {
            Notification_Basic result = apiInstance.deleteNotification(idTweet, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestNotificationControllerApi#deleteNotification");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestNotificationControllerApi;

public class RestNotificationControllerApiExample {
    public static void main(String[] args) {
        RestNotificationControllerApi apiInstance = new RestNotificationControllerApi();
        Long idTweet = 789; // Long | 
        String body = body_example; // String | 

        try {
            Notification_Basic result = apiInstance.deleteNotification(idTweet, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestNotificationControllerApi#deleteNotification");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestNotificationControllerApi *apiInstance = [[RestNotificationControllerApi alloc] init];
Long *idTweet = 789; //  (default to null)
String *body = body_example; //  (optional)

// Deletes a notification to a user
[apiInstance deleteNotificationWith:idTweet
    body:body
              completionHandler: ^(Notification_Basic 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.RestNotificationControllerApi()
var idTweet = 789; // {Long} 
var opts = {
  'body': body_example // {String} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new RestNotificationControllerApi();
            var idTweet = 789;  // Long |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                // Deletes a notification to a user
                Notification_Basic result = apiInstance.deleteNotification(idTweet, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestNotificationControllerApi.deleteNotification: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestNotificationControllerApi();
$idTweet = 789; // Long | 
$body = body_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestNotificationControllerApi->new();
my $idTweet = 789; # Long | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->deleteNotification(idTweet => $idTweet, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestNotificationControllerApi->deleteNotification: $@\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.RestNotificationControllerApi()
idTweet = 789 # Long |  (default to null)
body = body_example # String |  (optional)

try:
    # Deletes a notification to a user
    api_response = api_instance.delete_notification(idTweet, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestNotificationControllerApi->deleteNotification: %s\n" % e)
extern crate RestNotificationControllerApi;

pub fn main() {
    let idTweet = 789; // Long
    let body = body_example; // String

    let mut context = RestNotificationControllerApi::Context::default();
    let result = client.deleteNotification(idTweet, body, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
body

string
Query parameters
Name Description
idTweet*
Long (int64)
Required

Responses

Status: 200 - Notification Deleted

Status: 400 - Cannot delete the notification


getSomeMentions

Get some of the mentions of the current user


/api/notifications/more-mentions

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/notifications/more-mentions?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestNotificationControllerApi;

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

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

        // Create an instance of the API class
        RestNotificationControllerApi apiInstance = new RestNotificationControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            Notification_Basic result = apiInstance.getSomeMentions(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestNotificationControllerApi#getSomeMentions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestNotificationControllerApi;

public class RestNotificationControllerApiExample {
    public static void main(String[] args) {
        RestNotificationControllerApi apiInstance = new RestNotificationControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            Notification_Basic result = apiInstance.getSomeMentions(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestNotificationControllerApi#getSomeMentions");
            e.printStackTrace();
        }
    }
}


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

// Get some of the mentions of the current user
[apiInstance getSomeMentionsWith:from
    size:size
              completionHandler: ^(Notification_Basic 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.RestNotificationControllerApi()
var from = 56; // {Integer} 
var size = 56; // {Integer} 

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

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

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

            try {
                // Get some of the mentions of the current user
                Notification_Basic result = apiInstance.getSomeMentions(from, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestNotificationControllerApi.getSomeMentions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get some of the mentions of the current user
    api_response = api_instance.get_some_mentions(from, size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestNotificationControllerApi->getSomeMentions: %s\n" % e)
extern crate RestNotificationControllerApi;

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

    let mut context = RestNotificationControllerApi::Context::default();
    let result = client.getSomeMentions(from, size, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 202 - Mentions not found

Status: 200 - Mentions obtained


getSomeNotifications

Get some of the notification of the current user


/api/notifications/more-notifications

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/notifications/more-notifications?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestNotificationControllerApi;

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

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

        // Create an instance of the API class
        RestNotificationControllerApi apiInstance = new RestNotificationControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            Notification_Basic result = apiInstance.getSomeNotifications(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestNotificationControllerApi#getSomeNotifications");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestNotificationControllerApi;

public class RestNotificationControllerApiExample {
    public static void main(String[] args) {
        RestNotificationControllerApi apiInstance = new RestNotificationControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            Notification_Basic result = apiInstance.getSomeNotifications(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestNotificationControllerApi#getSomeNotifications");
            e.printStackTrace();
        }
    }
}


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

// Get some of the notification of the current user
[apiInstance getSomeNotificationsWith:from
    size:size
              completionHandler: ^(Notification_Basic 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.RestNotificationControllerApi()
var from = 56; // {Integer} 
var size = 56; // {Integer} 

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

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

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

            try {
                // Get some of the notification of the current user
                Notification_Basic result = apiInstance.getSomeNotifications(from, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestNotificationControllerApi.getSomeNotifications: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get some of the notification of the current user
    api_response = api_instance.get_some_notifications(from, size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestNotificationControllerApi->getSomeNotifications: %s\n" % e)
extern crate RestNotificationControllerApi;

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

    let mut context = RestNotificationControllerApi::Context::default();
    let result = client.getSomeNotifications(from, size, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 200 - Notifications obtained

Status: 202 - Notifications not found


postNotification

Post a new notification to a user


/api/notifications/new-notification

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/notifications/new-notification?idTweet=789&idOwner=789" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestNotificationControllerApi;

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

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

        // Create an instance of the API class
        RestNotificationControllerApi apiInstance = new RestNotificationControllerApi();
        Long idTweet = 789; // Long | 
        Long idOwner = 789; // Long | 
        String body = body_example; // String | 

        try {
            Notification_Basic result = apiInstance.postNotification(idTweet, idOwner, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestNotificationControllerApi#postNotification");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestNotificationControllerApi;

public class RestNotificationControllerApiExample {
    public static void main(String[] args) {
        RestNotificationControllerApi apiInstance = new RestNotificationControllerApi();
        Long idTweet = 789; // Long | 
        Long idOwner = 789; // Long | 
        String body = body_example; // String | 

        try {
            Notification_Basic result = apiInstance.postNotification(idTweet, idOwner, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestNotificationControllerApi#postNotification");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestNotificationControllerApi *apiInstance = [[RestNotificationControllerApi alloc] init];
Long *idTweet = 789; //  (default to null)
Long *idOwner = 789; //  (default to null)
String *body = body_example; //  (optional)

// Post a new notification to a user
[apiInstance postNotificationWith:idTweet
    idOwner:idOwner
    body:body
              completionHandler: ^(Notification_Basic 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.RestNotificationControllerApi()
var idTweet = 789; // {Long} 
var idOwner = 789; // {Long} 
var opts = {
  'body': body_example // {String} 
};

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

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

            // Create an instance of the API class
            var apiInstance = new RestNotificationControllerApi();
            var idTweet = 789;  // Long |  (default to null)
            var idOwner = 789;  // Long |  (default to null)
            var body = body_example;  // String |  (optional) 

            try {
                // Post a new notification to a user
                Notification_Basic result = apiInstance.postNotification(idTweet, idOwner, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestNotificationControllerApi.postNotification: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestNotificationControllerApi();
$idTweet = 789; // Long | 
$idOwner = 789; // Long | 
$body = body_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestNotificationControllerApi->new();
my $idTweet = 789; # Long | 
my $idOwner = 789; # Long | 
my $body = WWW::OPenAPIClient::Object::String->new(); # String | 

eval {
    my $result = $api_instance->postNotification(idTweet => $idTweet, idOwner => $idOwner, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestNotificationControllerApi->postNotification: $@\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.RestNotificationControllerApi()
idTweet = 789 # Long |  (default to null)
idOwner = 789 # Long |  (default to null)
body = body_example # String |  (optional)

try:
    # Post a new notification to a user
    api_response = api_instance.post_notification(idTweet, idOwner, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestNotificationControllerApi->postNotification: %s\n" % e)
extern crate RestNotificationControllerApi;

pub fn main() {
    let idTweet = 789; // Long
    let idOwner = 789; // Long
    let body = body_example; // String

    let mut context = RestNotificationControllerApi::Context::default();
    let result = client.postNotification(idTweet, idOwner, body, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
body

string
Query parameters
Name Description
idTweet*
Long (int64)
Required
idOwner*
Long (int64)
Required

Responses

Status: 201 - Notification Created

Status: 400 - Cannot create the notification

Status: 202 - The user notifies himself


RestProfileController

getFollowed

Get some followed users of a User


/api/profile/followed/{username}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/profile/followed/{username}?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestProfileControllerApi;

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

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

        // Create an instance of the API class
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 
        String username = username_example; // String | 

        try {
            Object result = apiInstance.getFollowed(from, size, username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProfileControllerApi#getFollowed");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestProfileControllerApi;

public class RestProfileControllerApiExample {
    public static void main(String[] args) {
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 
        String username = username_example; // String | 

        try {
            Object result = apiInstance.getFollowed(from, size, username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProfileControllerApi#getFollowed");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestProfileControllerApi *apiInstance = [[RestProfileControllerApi alloc] init];
Integer *from = 56; //  (default to null)
Integer *size = 56; //  (default to null)
String *username = username_example; //  (default to null)

// Get some followed users of a User
[apiInstance getFollowedWith:from
    size:size
    username:username
              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.RestProfileControllerApi()
var from = 56; // {Integer} 
var size = 56; // {Integer} 
var username = username_example; // {String} 

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

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

            // Create an instance of the API class
            var apiInstance = new RestProfileControllerApi();
            var from = 56;  // Integer |  (default to null)
            var size = 56;  // Integer |  (default to null)
            var username = username_example;  // String |  (default to null)

            try {
                // Get some followed users of a User
                Object result = apiInstance.getFollowed(from, size, username);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProfileControllerApi.getFollowed: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProfileControllerApi();
$from = 56; // Integer | 
$size = 56; // Integer | 
$username = username_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProfileControllerApi->new();
my $from = 56; # Integer | 
my $size = 56; # Integer | 
my $username = username_example; # String | 

eval {
    my $result = $api_instance->getFollowed(from => $from, size => $size, username => $username);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProfileControllerApi->getFollowed: $@\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.RestProfileControllerApi()
from = 56 # Integer |  (default to null)
size = 56 # Integer |  (default to null)
username = username_example # String |  (default to null)

try:
    # Get some followed users of a User
    api_response = api_instance.get_followed(from, size, username)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProfileControllerApi->getFollowed: %s\n" % e)
extern crate RestProfileControllerApi;

pub fn main() {
    let from = 56; // Integer
    let size = 56; // Integer
    let username = username_example; // String

    let mut context = RestProfileControllerApi::Context::default();
    let result = client.getFollowed(from, size, username, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
username*
String
Required
Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 404 - User not found

Status: 200 - Followed Found


getFollowers

Get some followers users of a User


/api/profile/followers/{username}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/profile/followers/{username}?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestProfileControllerApi;

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

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

        // Create an instance of the API class
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 
        String username = username_example; // String | 

        try {
            Object result = apiInstance.getFollowers(from, size, username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProfileControllerApi#getFollowers");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestProfileControllerApi;

public class RestProfileControllerApiExample {
    public static void main(String[] args) {
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 
        String username = username_example; // String | 

        try {
            Object result = apiInstance.getFollowers(from, size, username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProfileControllerApi#getFollowers");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestProfileControllerApi *apiInstance = [[RestProfileControllerApi alloc] init];
Integer *from = 56; //  (default to null)
Integer *size = 56; //  (default to null)
String *username = username_example; //  (default to null)

// Get some followers users of a User
[apiInstance getFollowersWith:from
    size:size
    username:username
              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.RestProfileControllerApi()
var from = 56; // {Integer} 
var size = 56; // {Integer} 
var username = username_example; // {String} 

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

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

            // Create an instance of the API class
            var apiInstance = new RestProfileControllerApi();
            var from = 56;  // Integer |  (default to null)
            var size = 56;  // Integer |  (default to null)
            var username = username_example;  // String |  (default to null)

            try {
                // Get some followers users of a User
                Object result = apiInstance.getFollowers(from, size, username);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProfileControllerApi.getFollowers: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProfileControllerApi();
$from = 56; // Integer | 
$size = 56; // Integer | 
$username = username_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProfileControllerApi->new();
my $from = 56; # Integer | 
my $size = 56; # Integer | 
my $username = username_example; # String | 

eval {
    my $result = $api_instance->getFollowers(from => $from, size => $size, username => $username);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestProfileControllerApi->getFollowers: $@\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.RestProfileControllerApi()
from = 56 # Integer |  (default to null)
size = 56 # Integer |  (default to null)
username = username_example # String |  (default to null)

try:
    # Get some followers users of a User
    api_response = api_instance.get_followers(from, size, username)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProfileControllerApi->getFollowers: %s\n" % e)
extern crate RestProfileControllerApi;

pub fn main() {
    let from = 56; // Integer
    let size = 56; // Integer
    let username = username_example; // String

    let mut context = RestProfileControllerApi::Context::default();
    let result = client.getFollowers(from, size, username, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
username*
String
Required
Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 404 - User not found

Status: 200 - Followed Found


getUserByUsername

Get a User


/api/profile/{username}

Usage and SDK Samples

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

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

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

        // Create an instance of the API class
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        String username = username_example; // String | 

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

public class RestProfileControllerApiExample {
    public static void main(String[] args) {
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        String username = username_example; // String | 

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


// Create an instance of the API class
RestProfileControllerApi *apiInstance = [[RestProfileControllerApi alloc] init];
String *username = username_example; //  (default to null)

// Get a User
[apiInstance getUserByUsernameWith:username
              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.RestProfileControllerApi()
var username = username_example; // {String} 

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

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

            // Create an instance of the API class
            var apiInstance = new RestProfileControllerApi();
            var username = username_example;  // String |  (default to null)

            try {
                // Get a User
                Object result = apiInstance.getUserByUsername(username);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProfileControllerApi.getUserByUsername: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProfileControllerApi();
$username = username_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProfileControllerApi->new();
my $username = username_example; # String | 

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

try:
    # Get a User
    api_response = api_instance.get_user_by_username(username)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProfileControllerApi->getUserByUsername: %s\n" % e)
extern crate RestProfileControllerApi;

pub fn main() {
    let username = username_example; // String

    let mut context = RestProfileControllerApi::Context::default();
    let result = client.getUserByUsername(username, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
username*
String
Required

Responses

Status: 404 - User not found

Status: 200 - User Found


toggleFollow

Follow or unfollow a user


/api/profile/toggleFollow/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost:8443/api/profile/toggleFollow/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestProfileControllerApi;

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

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

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

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

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

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


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

// Follow or unfollow a user
[apiInstance toggleFollowWith: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.RestProfileControllerApi()
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.toggleFollow(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Follow or unfollow a user
                Object result = apiInstance.toggleFollow(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProfileControllerApi.toggleFollow: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Follow or unfollow a user
    api_response = api_instance.toggle_follow(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProfileControllerApi->toggleFollow: %s\n" % e)
extern crate RestProfileControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 202 - User unfollowed

Status: 404 - User not found

Status: 200 - User followed


updateBiography

Update the biography associated to a user


/api/profile/updateBiography/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost:8443/api/profile/updateBiography/{id}?biography=biography_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestProfileControllerApi;

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

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

        // Create an instance of the API class
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Long id = 789; // Long | 
        String biography = biography_example; // String | 

        try {
            Object result = apiInstance.updateBiography(id, biography);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProfileControllerApi#updateBiography");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestProfileControllerApi;

public class RestProfileControllerApiExample {
    public static void main(String[] args) {
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Long id = 789; // Long | 
        String biography = biography_example; // String | 

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


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

// Update the biography associated to a user
[apiInstance updateBiographyWith:id
    biography:biography
              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.RestProfileControllerApi()
var id = 789; // {Long} 
var biography = biography_example; // {String} 

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

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

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

            try {
                // Update the biography associated to a user
                Object result = apiInstance.updateBiography(id, biography);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProfileControllerApi.updateBiography: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Update the biography associated to a user
    api_response = api_instance.update_biography(id, biography)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProfileControllerApi->updateBiography: %s\n" % e)
extern crate RestProfileControllerApi;

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

    let mut context = RestProfileControllerApi::Context::default();
    let result = client.updateBiography(id, biography, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Query parameters
Name Description
biography*
String
Required

Responses

Status: 404 - User not found

Status: 200 - Biography updated


updateNickname

Update the nickname associated to a user


/api/profile/updateNickname/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost:8443/api/profile/updateNickname/{id}?nickname=nickname_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestProfileControllerApi;

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

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

        // Create an instance of the API class
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Long id = 789; // Long | 
        String nickname = nickname_example; // String | 

        try {
            Object result = apiInstance.updateNickname(id, nickname);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProfileControllerApi#updateNickname");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestProfileControllerApi;

public class RestProfileControllerApiExample {
    public static void main(String[] args) {
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Long id = 789; // Long | 
        String nickname = nickname_example; // String | 

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


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

// Update the nickname associated to a user
[apiInstance updateNicknameWith:id
    nickname:nickname
              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.RestProfileControllerApi()
var id = 789; // {Long} 
var nickname = nickname_example; // {String} 

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

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

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

            try {
                // Update the nickname associated to a user
                Object result = apiInstance.updateNickname(id, nickname);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProfileControllerApi.updateNickname: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Update the nickname associated to a user
    api_response = api_instance.update_nickname(id, nickname)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProfileControllerApi->updateNickname: %s\n" % e)
extern crate RestProfileControllerApi;

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

    let mut context = RestProfileControllerApi::Context::default();
    let result = client.updateNickname(id, nickname, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Query parameters
Name Description
nickname*
String
Required

Responses

Status: 200 - Nickname updated

Status: 404 - User not found


updateProfileBanner

Update the profile banner associated to a user


/api/profile/updateProfileBanner/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/profile/updateProfileBanner/{id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestProfileControllerApi;

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

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

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

        try {
            Object result = apiInstance.updateProfileBanner(id, inlineObject1);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProfileControllerApi#updateProfileBanner");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestProfileControllerApi;

public class RestProfileControllerApiExample {
    public static void main(String[] args) {
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Long id = 789; // Long | 
        InlineObject1 inlineObject1 = ; // InlineObject1 | 

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


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

// Update the profile banner associated to a user
[apiInstance updateProfileBannerWith:id
    inlineObject1:inlineObject1
              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.RestProfileControllerApi()
var id = 789; // {Long} 
var opts = {
  'inlineObject1':  // {InlineObject1} 
};

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

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

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

            try {
                // Update the profile banner associated to a user
                Object result = apiInstance.updateProfileBanner(id, inlineObject1);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProfileControllerApi.updateProfileBanner: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Update the profile banner associated to a user
    api_response = api_instance.update_profile_banner(id, inlineObject1=inlineObject1)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProfileControllerApi->updateProfileBanner: %s\n" % e)
extern crate RestProfileControllerApi;

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

    let mut context = RestProfileControllerApi::Context::default();
    let result = client.updateProfileBanner(id, inlineObject1, &context).wait();

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

Scopes

Parameters

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

{
Required: file
file:
string (binary)

Responses

Status: 404 - User not found

Status: 200 - Profile banner updated


updateProfilePic

Update the profile pic associated to a user


/api/profile/updateProfilePicture/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/profile/updateProfilePicture/{id}" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestProfileControllerApi;

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

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

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

        try {
            Object result = apiInstance.updateProfilePic(id, inlineObject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProfileControllerApi#updateProfilePic");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestProfileControllerApi;

public class RestProfileControllerApiExample {
    public static void main(String[] args) {
        RestProfileControllerApi apiInstance = new RestProfileControllerApi();
        Long id = 789; // Long | 
        InlineObject inlineObject = ; // InlineObject | 

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


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

// Update the profile pic associated to a user
[apiInstance updateProfilePicWith:id
    inlineObject:inlineObject
              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.RestProfileControllerApi()
var id = 789; // {Long} 
var opts = {
  'inlineObject':  // {InlineObject} 
};

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

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

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

            try {
                // Update the profile pic associated to a user
                Object result = apiInstance.updateProfilePic(id, inlineObject);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProfileControllerApi.updateProfilePic: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Update the profile pic associated to a user
    api_response = api_instance.update_profile_pic(id, inlineObject=inlineObject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProfileControllerApi->updateProfilePic: %s\n" % e)
extern crate RestProfileControllerApi;

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

    let mut context = RestProfileControllerApi::Context::default();
    let result = client.updateProfilePic(id, inlineObject, &context).wait();

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

Scopes

Parameters

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

{
Required: file
file:
string (binary)

Responses

Status: 200 - Profile pic updated

Status: 404 - User not found


RestTweetController

deleteTweet

Delete a tweet of the current user


/api/tweet/delete/{id}

Usage and SDK Samples

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

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

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

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

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

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

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


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

// Delete a tweet of the current user
[apiInstance deleteTweetWith:id
              completionHandler: ^(Tweet_Basic 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.RestTweetControllerApi()
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.deleteTweet(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Delete a tweet of the current user
                Tweet_Basic result = apiInstance.deleteTweet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.deleteTweet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Delete a tweet of the current user
    api_response = api_instance.delete_tweet(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->deleteTweet: %s\n" % e)
extern crate RestTweetControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 404 - Tweet Not Found

Status: 201 - Tweet Created

Status: 403 - Forbidden action


getProfileTweets

Get some of the tweets written by the current user


/api/profile/{id}/tweets

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/profile/{id}/tweets?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTweetControllerApi;

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

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

        // Create an instance of the API class
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        Long id = 789; // Long | 
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            TweetInformation_Basic result = apiInstance.getProfileTweets(id, from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#getProfileTweets");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTweetControllerApi;

public class RestTweetControllerApiExample {
    public static void main(String[] args) {
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        Long id = 789; // Long | 
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            TweetInformation_Basic result = apiInstance.getProfileTweets(id, from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#getProfileTweets");
            e.printStackTrace();
        }
    }
}


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

// Get some of the tweets written by the current user
[apiInstance getProfileTweetsWith:id
    from:from
    size:size
              completionHandler: ^(TweetInformation_Basic 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.RestTweetControllerApi()
var id = 789; // {Long} 
var from = 56; // {Integer} 
var size = 56; // {Integer} 

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

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

            // Create an instance of the API class
            var apiInstance = new RestTweetControllerApi();
            var id = 789;  // Long |  (default to null)
            var from = 56;  // Integer |  (default to null)
            var size = 56;  // Integer |  (default to null)

            try {
                // Get some of the tweets written by the current user
                TweetInformation_Basic result = apiInstance.getProfileTweets(id, from, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.getProfileTweets: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestTweetControllerApi();
$id = 789; // Long | 
$from = 56; // Integer | 
$size = 56; // Integer | 

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

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

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

try:
    # Get some of the tweets written by the current user
    api_response = api_instance.get_profile_tweets(id, from, size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->getProfileTweets: %s\n" % e)
extern crate RestTweetControllerApi;

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

    let mut context = RestTweetControllerApi::Context::default();
    let result = client.getProfileTweets(id, from, size, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 200 - Tweets obtained

Status: 404 - Tweets not found

Status: 202 - User not found


getTweetsForAUser

Get some of the tweets owned by the followed users of the current user


/api/tweets

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tweets?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTweetControllerApi;

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

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

        // Create an instance of the API class
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            TweetInformation_Basic result = apiInstance.getTweetsForAUser(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#getTweetsForAUser");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTweetControllerApi;

public class RestTweetControllerApiExample {
    public static void main(String[] args) {
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            TweetInformation_Basic result = apiInstance.getTweetsForAUser(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#getTweetsForAUser");
            e.printStackTrace();
        }
    }
}


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

// Get some of the tweets owned by the followed users of the current user
[apiInstance getTweetsForAUserWith:from
    size:size
              completionHandler: ^(TweetInformation_Basic 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.RestTweetControllerApi()
var from = 56; // {Integer} 
var size = 56; // {Integer} 

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

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

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

            try {
                // Get some of the tweets owned by the followed users of the current user
                TweetInformation_Basic result = apiInstance.getTweetsForAUser(from, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.getTweetsForAUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get some of the tweets owned by the followed users of the current user
    api_response = api_instance.get_tweets_for_a_user(from, size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->getTweetsForAUser: %s\n" % e)
extern crate RestTweetControllerApi;

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

    let mut context = RestTweetControllerApi::Context::default();
    let result = client.getTweetsForAUser(from, size, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 200 - Tweets obtained

Status: 404 - No tweets found for current user


getTweetsForBookmarks

Get some of the bookmarks of the current user


/api/bookmarks

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/bookmarks?from=56&size=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTweetControllerApi;

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

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

        // Create an instance of the API class
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            TweetInformation_Basic result = apiInstance.getTweetsForBookmarks(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#getTweetsForBookmarks");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTweetControllerApi;

public class RestTweetControllerApiExample {
    public static void main(String[] args) {
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        Integer from = 56; // Integer | 
        Integer size = 56; // Integer | 

        try {
            TweetInformation_Basic result = apiInstance.getTweetsForBookmarks(from, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#getTweetsForBookmarks");
            e.printStackTrace();
        }
    }
}


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

// Get some of the bookmarks of the current user
[apiInstance getTweetsForBookmarksWith:from
    size:size
              completionHandler: ^(TweetInformation_Basic 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.RestTweetControllerApi()
var from = 56; // {Integer} 
var size = 56; // {Integer} 

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

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

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

            try {
                // Get some of the bookmarks of the current user
                TweetInformation_Basic result = apiInstance.getTweetsForBookmarks(from, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.getTweetsForBookmarks: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Get some of the bookmarks of the current user
    api_response = api_instance.get_tweets_for_bookmarks(from, size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->getTweetsForBookmarks: %s\n" % e)
extern crate RestTweetControllerApi;

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

    let mut context = RestTweetControllerApi::Context::default();
    let result = client.getTweetsForBookmarks(from, size, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
from*
Integer (int32)
Required
size*
Integer (int32)
Required

Responses

Status: 200 - Bookmarks obtained

Status: 202 - Bookmarks list empty


postTweet

Post a new tweet by the current user replying a tweet


/api/tweets/reply-tweet/{idTweetReplied}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tweets/reply-tweet/{idTweetReplied}?text=text_example&files="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTweetControllerApi;

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

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

        // Create an instance of the API class
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        String text = text_example; // String | 
        array[File] files = ; // array[File] | 
        Long idTweetReplied = 789; // Long | 

        try {
            Tweet_Basic result = apiInstance.postTweet(text, files, idTweetReplied);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#postTweet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTweetControllerApi;

public class RestTweetControllerApiExample {
    public static void main(String[] args) {
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        String text = text_example; // String | 
        array[File] files = ; // array[File] | 
        Long idTweetReplied = 789; // Long | 

        try {
            Tweet_Basic result = apiInstance.postTweet(text, files, idTweetReplied);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#postTweet");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestTweetControllerApi *apiInstance = [[RestTweetControllerApi alloc] init];
String *text = text_example; //  (default to null)
array[File] *files = ; //  (default to null)
Long *idTweetReplied = 789; //  (default to null)

// Post a new tweet by the current user replying a tweet
[apiInstance postTweetWith:text
    files:files
    idTweetReplied:idTweetReplied
              completionHandler: ^(Tweet_Basic 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.RestTweetControllerApi()
var text = text_example; // {String} 
var files = ; // {array[File]} 
var idTweetReplied = 789; // {Long} 

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

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

            // Create an instance of the API class
            var apiInstance = new RestTweetControllerApi();
            var text = text_example;  // String |  (default to null)
            var files = new array[File](); // array[File] |  (default to null)
            var idTweetReplied = 789;  // Long |  (default to null)

            try {
                // Post a new tweet by the current user replying a tweet
                Tweet_Basic result = apiInstance.postTweet(text, files, idTweetReplied);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.postTweet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestTweetControllerApi();
$text = text_example; // String | 
$files = ; // array[File] | 
$idTweetReplied = 789; // Long | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestTweetControllerApi->new();
my $text = text_example; # String | 
my $files = []; # array[File] | 
my $idTweetReplied = 789; # Long | 

eval {
    my $result = $api_instance->postTweet(text => $text, files => $files, idTweetReplied => $idTweetReplied);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestTweetControllerApi->postTweet: $@\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.RestTweetControllerApi()
text = text_example # String |  (default to null)
files =  # array[File] |  (default to null)
idTweetReplied = 789 # Long |  (default to null)

try:
    # Post a new tweet by the current user replying a tweet
    api_response = api_instance.post_tweet(text, files, idTweetReplied)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->postTweet: %s\n" % e)
extern crate RestTweetControllerApi;

pub fn main() {
    let text = text_example; // String
    let files = ; // array[File]
    let idTweetReplied = 789; // Long

    let mut context = RestTweetControllerApi::Context::default();
    let result = client.postTweet(text, files, idTweetReplied, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
idTweetReplied*
Long (int64)
Required
Query parameters
Name Description
text*
String
Required
files*
array[File] (binary)
Required

Responses

Status: 404 - Tweet Not Found

Status: 201 - Comment Created


postTweet1

Post a new tweet by the current user


/api/tweets/new-tweet

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tweets/new-tweet?text=text_example&files="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTweetControllerApi;

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

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

        // Create an instance of the API class
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        String text = text_example; // String | 
        array[File] files = ; // array[File] | 

        try {
            Tweet_Basic result = apiInstance.postTweet1(text, files);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#postTweet1");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTweetControllerApi;

public class RestTweetControllerApiExample {
    public static void main(String[] args) {
        RestTweetControllerApi apiInstance = new RestTweetControllerApi();
        String text = text_example; // String | 
        array[File] files = ; // array[File] | 

        try {
            Tweet_Basic result = apiInstance.postTweet1(text, files);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTweetControllerApi#postTweet1");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestTweetControllerApi *apiInstance = [[RestTweetControllerApi alloc] init];
String *text = text_example; //  (default to null)
array[File] *files = ; //  (default to null)

// Post a new tweet by the current user
[apiInstance postTweet1With:text
    files:files
              completionHandler: ^(Tweet_Basic 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.RestTweetControllerApi()
var text = text_example; // {String} 
var files = ; // {array[File]} 

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

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

            // Create an instance of the API class
            var apiInstance = new RestTweetControllerApi();
            var text = text_example;  // String |  (default to null)
            var files = new array[File](); // array[File] |  (default to null)

            try {
                // Post a new tweet by the current user
                Tweet_Basic result = apiInstance.postTweet1(text, files);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.postTweet1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestTweetControllerApi();
$text = text_example; // String | 
$files = ; // array[File] | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestTweetControllerApi->new();
my $text = text_example; # String | 
my $files = []; # array[File] | 

eval {
    my $result = $api_instance->postTweet1(text => $text, files => $files);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestTweetControllerApi->postTweet1: $@\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.RestTweetControllerApi()
text = text_example # String |  (default to null)
files =  # array[File] |  (default to null)

try:
    # Post a new tweet by the current user
    api_response = api_instance.post_tweet1(text, files)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->postTweet1: %s\n" % e)
extern crate RestTweetControllerApi;

pub fn main() {
    let text = text_example; // String
    let files = ; // array[File]

    let mut context = RestTweetControllerApi::Context::default();
    let result = client.postTweet1(text, files, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
text*
String
Required
files*
array[File] (binary)
Required

Responses

Status: 201 - Tweet Created


toggleBookmark

Add or remove a tweet from the bookmark list of the current user


/api/tweet/bookmark/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tweet/bookmark/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTweetControllerApi;

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

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

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

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

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

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


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

// Add or remove a tweet from the bookmark list of the current user
[apiInstance toggleBookmarkWith:id
              completionHandler: ^(TweetInformation_Basic 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.RestTweetControllerApi()
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.toggleBookmark(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Add or remove a tweet from the bookmark list of the current user
                TweetInformation_Basic result = apiInstance.toggleBookmark(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.toggleBookmark: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Add or remove a tweet from the bookmark list of the current user
    api_response = api_instance.toggle_bookmark(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->toggleBookmark: %s\n" % e)
extern crate RestTweetControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - Bookmarked

Status: 404 - Tweet Not Found

Status: 202 - Bookmark Removed


toggleLike

Give or remove like of a tweet


/api/tweet/like/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tweet/like/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTweetControllerApi;

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

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

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

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

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

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


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

// Give or remove like of a tweet
[apiInstance toggleLikeWith:id
              completionHandler: ^(TweetInformation_Basic 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.RestTweetControllerApi()
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.toggleLike(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Give or remove like of a tweet
                TweetInformation_Basic result = apiInstance.toggleLike(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.toggleLike: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Give or remove like of a tweet
    api_response = api_instance.toggle_like(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->toggleLike: %s\n" % e)
extern crate RestTweetControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - Like given

Status: 404 - Tweet Not Found

Status: 202 - Like removed


toggleRetweet

Give or remove retweet of a tweet


/api/tweet/retweet/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tweet/retweet/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTweetControllerApi;

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

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

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

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

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

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


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

// Give or remove retweet of a tweet
[apiInstance toggleRetweetWith:id
              completionHandler: ^(TweetInformation_Basic 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.RestTweetControllerApi()
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.toggleRetweet(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                // Give or remove retweet of a tweet
                TweetInformation_Basic result = apiInstance.toggleRetweet(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTweetControllerApi.toggleRetweet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

try:
    # Give or remove retweet of a tweet
    api_response = api_instance.toggle_retweet(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTweetControllerApi->toggleRetweet: %s\n" % e)
extern crate RestTweetControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 202 - Retweet removed

Status: 404 - Tweet Not Found

Status: 200 - Retweet given


SearchRestController

searchHashtags

Find Hashtags which contains the keyword in their username


/api/search/hashtags/{keyword}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/search/hashtags/{keyword}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SearchRestControllerApi;

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

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

        // Create an instance of the API class
        SearchRestControllerApi apiInstance = new SearchRestControllerApi();
        String keyword = keyword_example; // String | 

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

public class SearchRestControllerApiExample {
    public static void main(String[] args) {
        SearchRestControllerApi apiInstance = new SearchRestControllerApi();
        String keyword = keyword_example; // String | 

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


// Create an instance of the API class
SearchRestControllerApi *apiInstance = [[SearchRestControllerApi alloc] init];
String *keyword = keyword_example; //  (default to null)

// Find Hashtags which contains the keyword in their username
[apiInstance searchHashtagsWith:keyword
              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.SearchRestControllerApi()
var keyword = keyword_example; // {String} 

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

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

            // Create an instance of the API class
            var apiInstance = new SearchRestControllerApi();
            var keyword = keyword_example;  // String |  (default to null)

            try {
                // Find Hashtags which contains the keyword in their username
                apiInstance.searchHashtags(keyword);
            } catch (Exception e) {
                Debug.Print("Exception when calling SearchRestControllerApi.searchHashtags: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SearchRestControllerApi();
$keyword = keyword_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SearchRestControllerApi->new();
my $keyword = keyword_example; # String | 

eval {
    $api_instance->searchHashtags(keyword => $keyword);
};
if ($@) {
    warn "Exception when calling SearchRestControllerApi->searchHashtags: $@\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.SearchRestControllerApi()
keyword = keyword_example # String |  (default to null)

try:
    # Find Hashtags which contains the keyword in their username
    api_instance.search_hashtags(keyword)
except ApiException as e:
    print("Exception when calling SearchRestControllerApi->searchHashtags: %s\n" % e)
extern crate SearchRestControllerApi;

pub fn main() {
    let keyword = keyword_example; // String

    let mut context = SearchRestControllerApi::Context::default();
    let result = client.searchHashtags(keyword, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
keyword*
String
Required

Responses

Status: 200 - Profiles Found

Status: 404 - No hashtags found that match the keyword


searchProfiles

Find profiles which contains the keyword in their username


/api/search/profiles/{keyword}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/search/profiles/{keyword}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.SearchRestControllerApi;

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

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

        // Create an instance of the API class
        SearchRestControllerApi apiInstance = new SearchRestControllerApi();
        String keyword = keyword_example; // String | 

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

public class SearchRestControllerApiExample {
    public static void main(String[] args) {
        SearchRestControllerApi apiInstance = new SearchRestControllerApi();
        String keyword = keyword_example; // String | 

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


// Create an instance of the API class
SearchRestControllerApi *apiInstance = [[SearchRestControllerApi alloc] init];
String *keyword = keyword_example; //  (default to null)

// Find profiles which contains the keyword in their username
[apiInstance searchProfilesWith:keyword
              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.SearchRestControllerApi()
var keyword = keyword_example; // {String} 

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

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

            // Create an instance of the API class
            var apiInstance = new SearchRestControllerApi();
            var keyword = keyword_example;  // String |  (default to null)

            try {
                // Find profiles which contains the keyword in their username
                apiInstance.searchProfiles(keyword);
            } catch (Exception e) {
                Debug.Print("Exception when calling SearchRestControllerApi.searchProfiles: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\SearchRestControllerApi();
$keyword = keyword_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::SearchRestControllerApi->new();
my $keyword = keyword_example; # String | 

eval {
    $api_instance->searchProfiles(keyword => $keyword);
};
if ($@) {
    warn "Exception when calling SearchRestControllerApi->searchProfiles: $@\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.SearchRestControllerApi()
keyword = keyword_example # String |  (default to null)

try:
    # Find profiles which contains the keyword in their username
    api_instance.search_profiles(keyword)
except ApiException as e:
    print("Exception when calling SearchRestControllerApi->searchProfiles: %s\n" % e)
extern crate SearchRestControllerApi;

pub fn main() {
    let keyword = keyword_example; // String

    let mut context = SearchRestControllerApi::Context::default();
    let result = client.searchProfiles(keyword, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
keyword*
String
Required

Responses

Status: 404 - No profiles found that match the keyword

Status: 200 - Profiles Found


UserSignUpRestController

signup

Redirect the user to the signUp view


/api/signup

Usage and SDK Samples

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

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

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

        // Create an instance of the API class
        UserSignUpRestControllerApi apiInstance = new UserSignUpRestControllerApi();
        RegisteredRequest registeredRequest = ; // RegisteredRequest | 

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

public class UserSignUpRestControllerApiExample {
    public static void main(String[] args) {
        UserSignUpRestControllerApi apiInstance = new UserSignUpRestControllerApi();
        RegisteredRequest registeredRequest = ; // RegisteredRequest | 

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


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

// Redirect the user to the signUp view
[apiInstance signupWith:registeredRequest
              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.UserSignUpRestControllerApi()
var registeredRequest = ; // {RegisteredRequest} 

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

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

            // Create an instance of the API class
            var apiInstance = new UserSignUpRestControllerApi();
            var registeredRequest = new RegisteredRequest(); // RegisteredRequest | 

            try {
                // Redirect the user to the signUp view
                apiInstance.signup(registeredRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserSignUpRestControllerApi.signup: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserSignUpRestControllerApi();
$registeredRequest = ; // RegisteredRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserSignUpRestControllerApi->new();
my $registeredRequest = WWW::OPenAPIClient::Object::RegisteredRequest->new(); # RegisteredRequest | 

eval {
    $api_instance->signup(registeredRequest => $registeredRequest);
};
if ($@) {
    warn "Exception when calling UserSignUpRestControllerApi->signup: $@\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.UserSignUpRestControllerApi()
registeredRequest =  # RegisteredRequest | 

try:
    # Redirect the user to the signUp view
    api_instance.signup(registeredRequest)
except ApiException as e:
    print("Exception when calling UserSignUpRestControllerApi->signup: %s\n" % e)
extern crate UserSignUpRestControllerApi;

pub fn main() {
    let registeredRequest = ; // RegisteredRequest

    let mut context = UserSignUpRestControllerApi::Context::default();
    let result = client.signup(registeredRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
registeredRequest *

{
email:
string
username:
string
password:
string

Responses

Status: 200 - Registration successful

Status: 400 - Invalid request


verifyUser

Check the verification code to create an account


/api/verify

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/verify?code=code_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserSignUpRestControllerApi;

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

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

        // Create an instance of the API class
        UserSignUpRestControllerApi apiInstance = new UserSignUpRestControllerApi();
        String code = code_example; // String | 

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

public class UserSignUpRestControllerApiExample {
    public static void main(String[] args) {
        UserSignUpRestControllerApi apiInstance = new UserSignUpRestControllerApi();
        String code = code_example; // String | 

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


// Create an instance of the API class
UserSignUpRestControllerApi *apiInstance = [[UserSignUpRestControllerApi alloc] init];
String *code = code_example; //  (default to null)

// Check the verification code to create an account
[apiInstance verifyUserWith:code
              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.UserSignUpRestControllerApi()
var code = code_example; // {String} 

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

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

            // Create an instance of the API class
            var apiInstance = new UserSignUpRestControllerApi();
            var code = code_example;  // String |  (default to null)

            try {
                // Check the verification code to create an account
                Object result = apiInstance.verifyUser(code);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserSignUpRestControllerApi.verifyUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserSignUpRestControllerApi();
$code = code_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserSignUpRestControllerApi->new();
my $code = code_example; # String | 

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

try:
    # Check the verification code to create an account
    api_response = api_instance.verify_user(code)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserSignUpRestControllerApi->verifyUser: %s\n" % e)
extern crate UserSignUpRestControllerApi;

pub fn main() {
    let code = code_example; // String

    let mut context = UserSignUpRestControllerApi::Context::default();
    let result = client.verifyUser(code, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
code*
String
Required

Responses

Status: 200 - Account verified

Status: 400 - invalid Token