TIXNGO REST API

Default

organizerAccessValidationPost

Validate the qrcode passed in parameter according to the chosen mode


/organizer/access/validation

Usage and SDK Samples

curl -X POST\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/access/validation"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        OrganizerAccessValidationRequest organizerAccessValidationRequest = ; // OrganizerAccessValidationRequest | 
        
        try {
            OrganizerAccessValidationResponse result = apiInstance.organizerAccessValidationPost(organizerAccessValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccessValidationPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        OrganizerAccessValidationRequest organizerAccessValidationRequest = ; // OrganizerAccessValidationRequest | 
        
        try {
            OrganizerAccessValidationResponse result = apiInstance.organizerAccessValidationPost(organizerAccessValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccessValidationPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
OrganizerAccessValidationRequest *organizerAccessValidationRequest = ; //  (optional)

[apiInstance organizerAccessValidationPostWith:organizerAccessValidationRequest
              completionHandler: ^(OrganizerAccessValidationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var opts = {
  'organizerAccessValidationRequest':  // {OrganizerAccessValidationRequest} 
};

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

namespace Example
{
    public class organizerAccessValidationPostExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var organizerAccessValidationRequest = new OrganizerAccessValidationRequest(); // OrganizerAccessValidationRequest |  (optional) 

            try {
                OrganizerAccessValidationResponse result = apiInstance.organizerAccessValidationPost(organizerAccessValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccessValidationPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
organizerAccessValidationRequest =  # OrganizerAccessValidationRequest |  (optional)

try: 
    api_response = api_instance.organizer_access_validation_post(organizerAccessValidationRequest=organizerAccessValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccessValidationPost: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let organizerAccessValidationRequest = ; // OrganizerAccessValidationRequest

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

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

Scopes

Parameters

Body parameters
Name Description
organizerAccessValidationRequest

Responses


organizerAccountDelete

Delete the given operator account


/organizer/account

Usage and SDK Samples

curl -X DELETE\
-H "x-api-key: [[apiKey]]"\
 "https://api.tixngo.io/v3/organizer/account?email="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String email = email_example; // String | 
        
        try {
            apiInstance.organizerAccountDelete(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountDelete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String email = email_example; // String | 
        
        try {
            apiInstance.organizerAccountDelete(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *email = email_example; //  (default to null)

[apiInstance organizerAccountDeleteWith:email
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var email = email_example; // {String} 

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

namespace Example
{
    public class organizerAccountDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var email = email_example;  // String |  (default to null)

            try {
                apiInstance.organizerAccountDelete(email);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

eval { 
    $api_instance->organizerAccountDelete(email => $email);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerAccountDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
email = email_example # String |  (default to null)

try: 
    api_instance.organizer_account_delete(email)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountDelete: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let email = email_example; // String

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

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

Scopes

Parameters

Query parameters
Name Description
email*
String
Required

Responses


organizerAccountPost

Request a new operator account with given role


/organizer/account

Usage and SDK Samples

curl -X POST\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/account"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        OrganizerAccountRequest organizerAccountRequest = ; // OrganizerAccountRequest | 
        
        try {
            OrganizerAccount result = apiInstance.organizerAccountPost(organizerAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        OrganizerAccountRequest organizerAccountRequest = ; // OrganizerAccountRequest | 
        
        try {
            OrganizerAccount result = apiInstance.organizerAccountPost(organizerAccountRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
OrganizerAccountRequest *organizerAccountRequest = ; //  (optional)

[apiInstance organizerAccountPostWith:organizerAccountRequest
              completionHandler: ^(OrganizerAccount output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var opts = {
  'organizerAccountRequest':  // {OrganizerAccountRequest} 
};

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

namespace Example
{
    public class organizerAccountPostExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var organizerAccountRequest = new OrganizerAccountRequest(); // OrganizerAccountRequest |  (optional) 

            try {
                OrganizerAccount result = apiInstance.organizerAccountPost(organizerAccountRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
organizerAccountRequest =  # OrganizerAccountRequest |  (optional)

try: 
    api_response = api_instance.organizer_account_post(organizerAccountRequest=organizerAccountRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerAccountPost: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let organizerAccountRequest = ; // OrganizerAccountRequest

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

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

Scopes

Parameters

Body parameters
Name Description
organizerAccountRequest

Responses


organizerAccountsGet

Retrieve the requester accounts as list


/organizer/accounts

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/accounts"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            array[OrganizerAccount] result = apiInstance.organizerAccountsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            array[OrganizerAccount] result = apiInstance.organizerAccountsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerAccountsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


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

[apiInstance organizerAccountsGetWithCompletionHandler: 
              ^(array[OrganizerAccount] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

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

namespace Example
{
    public class organizerAccountsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                array[OrganizerAccount] result = apiInstance.organizerAccountsGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerAccountsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerActivationGet

[OPERATOR] Ask the backend to check for organizer activation status.


/organizer/activation

Usage and SDK Samples

curl -X GET\
-H "Authorization: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/activation"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: tyxr-organizers
        ApiKeyAuth tyxr-organizers = (ApiKeyAuth) defaultClient.getAuthentication("tyxr-organizers");
        tyxr-organizers.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //tyxr-organizers.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerActivationResponse result = apiInstance.organizerActivationGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerActivationGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerActivationResponse result = apiInstance.organizerActivationGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerActivationGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: tyxr-organizers)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


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

[apiInstance organizerActivationGetWithCompletionHandler: 
              ^(OrganizerActivationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: tyxr-organizers
var tyxr-organizers = defaultClient.authentications['tyxr-organizers'];
tyxr-organizers.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//tyxr-organizers.apiKeyPrefix['Authorization'] = "Token";

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

namespace Example
{
    public class organizerActivationGetExample
    {
        public void main()
        {
            // Configure API key authorization: tyxr-organizers
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                OrganizerActivationResponse result = apiInstance.organizerActivationGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerActivationGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: tyxr-organizers
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

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

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

# Configure API key authorization: tyxr-organizers
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

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

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

# Configure API key authorization: tyxr-organizers
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerApikeyDelete

[OPERATOR] Delete/Revoke the apikey for the current organizer.


/organizer/apikey

Usage and SDK Samples

curl -X DELETE\
-H "Authorization: [[apiKey]]"\
 "https://api.tixngo.io/v3/organizer/apikey"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: tyxr-organizers
        ApiKeyAuth tyxr-organizers = (ApiKeyAuth) defaultClient.getAuthentication("tyxr-organizers");
        tyxr-organizers.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //tyxr-organizers.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerApikeyDelete();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyDelete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            apiInstance.organizerApikeyDelete();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: tyxr-organizers)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


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

[apiInstance organizerApikeyDeleteWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: tyxr-organizers
var tyxr-organizers = defaultClient.authentications['tyxr-organizers'];
tyxr-organizers.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//tyxr-organizers.apiKeyPrefix['Authorization'] = "Token";

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

namespace Example
{
    public class organizerApikeyDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: tyxr-organizers
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                apiInstance.organizerApikeyDelete();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApikeyDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: tyxr-organizers
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

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

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

# Configure API key authorization: tyxr-organizers
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

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

eval { 
    $api_instance->organizerApikeyDelete();
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApikeyDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: tyxr-organizers
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

try: 
    api_instance.organizer_apikey_delete()
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApikeyDelete: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerApikeyGet

[OPERATOR] Get the apikey for the current organizer. If the key does not exist, this method implicitly creates one.


/organizer/apikey

Usage and SDK Samples

curl -X GET\
-H "Authorization: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/apikey"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: tyxr-organizers
        ApiKeyAuth tyxr-organizers = (ApiKeyAuth) defaultClient.getAuthentication("tyxr-organizers");
        tyxr-organizers.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //tyxr-organizers.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerApikeyResponse result = apiInstance.organizerApikeyGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerApikeyResponse result = apiInstance.organizerApikeyGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApikeyGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: tyxr-organizers)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


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

[apiInstance organizerApikeyGetWithCompletionHandler: 
              ^(OrganizerApikeyResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: tyxr-organizers
var tyxr-organizers = defaultClient.authentications['tyxr-organizers'];
tyxr-organizers.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//tyxr-organizers.apiKeyPrefix['Authorization'] = "Token";

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

namespace Example
{
    public class organizerApikeyGetExample
    {
        public void main()
        {
            // Configure API key authorization: tyxr-organizers
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                OrganizerApikeyResponse result = apiInstance.organizerApikeyGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApikeyGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: tyxr-organizers
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

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

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

# Configure API key authorization: tyxr-organizers
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

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

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

# Configure API key authorization: tyxr-organizers
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerApplicationFeaturesAppIdGet

Get the list of all the organizer's application features, for all applications


/organizer/application-features/{appId}

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/application-features/{appId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        
        try {
            array[OrganizerApplicationFeature] result = apiInstance.organizerApplicationFeaturesAppIdGet(appId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        
        try {
            array[OrganizerApplicationFeature] result = apiInstance.organizerApplicationFeaturesAppIdGet(appId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *appId = appId_example; // the app id related to the feature (default to null)

[apiInstance organizerApplicationFeaturesAppIdGetWith:appId
              completionHandler: ^(array[OrganizerApplicationFeature] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var appId = appId_example; // {String} the app id related to the feature

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

namespace Example
{
    public class organizerApplicationFeaturesAppIdGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var appId = appId_example;  // String | the app id related to the feature (default to null)

            try {
                array[OrganizerApplicationFeature] result = apiInstance.organizerApplicationFeaturesAppIdGet(appId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationFeaturesAppIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$appId = appId_example; // String | the app id related to the feature

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $appId = appId_example; # String | the app id related to the feature

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
appId = appId_example # String | the app id related to the feature (default to null)

try: 
    api_response = api_instance.organizer_application_features_app_id_get(appId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationFeaturesAppIdGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let appId = appId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
appId*
String
the app id related to the feature
Required

Responses


organizerApplicationFeaturesAppIdPatch

Get the list of all the organizer's application features, for all applications


/organizer/application-features/{appId}

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/application-features/{appId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        array[OrganizerApplicationFeature] organizerApplicationFeature = ; // array[OrganizerApplicationFeature] | 
        
        try {
            apiInstance.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String appId = appId_example; // String | the app id related to the feature
        array[OrganizerApplicationFeature] organizerApplicationFeature = ; // array[OrganizerApplicationFeature] | 
        
        try {
            apiInstance.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationFeaturesAppIdPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *appId = appId_example; // the app id related to the feature (default to null)
array[OrganizerApplicationFeature] *organizerApplicationFeature = ; //  (optional)

[apiInstance organizerApplicationFeaturesAppIdPatchWith:appId
    organizerApplicationFeature:organizerApplicationFeature
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var appId = appId_example; // {String} the app id related to the feature
var opts = {
  'organizerApplicationFeature':  // {array[OrganizerApplicationFeature]} 
};

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

namespace Example
{
    public class organizerApplicationFeaturesAppIdPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var appId = appId_example;  // String | the app id related to the feature (default to null)
            var organizerApplicationFeature = new array[OrganizerApplicationFeature](); // array[OrganizerApplicationFeature] |  (optional) 

            try {
                apiInstance.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationFeaturesAppIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$appId = appId_example; // String | the app id related to the feature
$organizerApplicationFeature = ; // array[OrganizerApplicationFeature] | 

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $appId = appId_example; # String | the app id related to the feature
my $organizerApplicationFeature = [WWW::OPenAPIClient::Object::array[OrganizerApplicationFeature]->new()]; # array[OrganizerApplicationFeature] | 

eval { 
    $api_instance->organizerApplicationFeaturesAppIdPatch(appId => $appId, organizerApplicationFeature => $organizerApplicationFeature);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationFeaturesAppIdPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
appId = appId_example # String | the app id related to the feature (default to null)
organizerApplicationFeature =  # array[OrganizerApplicationFeature] |  (optional)

try: 
    api_instance.organizer_application_features_app_id_patch(appId, organizerApplicationFeature=organizerApplicationFeature)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationFeaturesAppIdPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let appId = appId_example; // String
    let organizerApplicationFeature = ; // array[OrganizerApplicationFeature]

    let mut context = DefaultApi::Context::default();
    let result = client.organizerApplicationFeaturesAppIdPatch(appId, organizerApplicationFeature, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
appId*
String
the app id related to the feature
Required
Body parameters
Name Description
organizerApplicationFeature

Responses


organizerApplicationSettingsGet

Get the spectator application settings for the applications (mobileAppId)


/organizer/application-settings

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/application-settings?mobileAppId=&key=&offset=&limit="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 
        String key = key_example; // String | 
        
        try {
            ApplicationSettings result = apiInstance.organizerApplicationSettingsGet(offset, limit, mobileAppId, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String mobileAppId = mobileAppId_example; // String | 
        String key = key_example; // String | 
        
        try {
            ApplicationSettings result = apiInstance.organizerApplicationSettingsGet(offset, limit, mobileAppId, key);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *offset = offset_example; //  (default to null)
String *limit = limit_example; //  (default to null)
String *mobileAppId = mobileAppId_example; //  (optional) (default to null)
String *key = key_example; //  (optional) (default to null)

[apiInstance organizerApplicationSettingsGetWith:offset
    limit:limit
    mobileAppId:mobileAppId
    key:key
              completionHandler: ^(ApplicationSettings output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var offset = offset_example; // {String} 
var limit = limit_example; // {String} 
var opts = {
  'mobileAppId': mobileAppId_example, // {String} 
  'key': key_example // {String} 
};

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

namespace Example
{
    public class organizerApplicationSettingsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var offset = offset_example;  // String |  (default to null)
            var limit = limit_example;  // String |  (default to null)
            var mobileAppId = mobileAppId_example;  // String |  (optional)  (default to null)
            var key = key_example;  // String |  (optional)  (default to null)

            try {
                ApplicationSettings result = apiInstance.organizerApplicationSettingsGet(offset, limit, mobileAppId, key);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$offset = offset_example; // String | 
$limit = limit_example; // String | 
$mobileAppId = mobileAppId_example; // String | 
$key = key_example; // String | 

try {
    $result = $api_instance->organizerApplicationSettingsGet($offset, $limit, $mobileAppId, $key);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerApplicationSettingsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $offset = offset_example; # String | 
my $limit = limit_example; # String | 
my $mobileAppId = mobileAppId_example; # String | 
my $key = key_example; # String | 

eval { 
    my $result = $api_instance->organizerApplicationSettingsGet(offset => $offset, limit => $limit, mobileAppId => $mobileAppId, key => $key);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerApplicationSettingsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
offset = offset_example # String |  (default to null)
limit = limit_example # String |  (default to null)
mobileAppId = mobileAppId_example # String |  (optional) (default to null)
key = key_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_application_settings_get(offset, limit, mobileAppId=mobileAppId, key=key)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let offset = offset_example; // String
    let limit = limit_example; // String
    let mobileAppId = mobileAppId_example; // String
    let key = key_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerApplicationSettingsGet(offset, limit, mobileAppId, key, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
mobileAppId
String
key
String
offset*
String
Required
limit*
String
Required

Responses


organizerApplicationSettingsMobileAppIdSupportedLanguagesGet

Get a list of supported languages for the given mobileAppId


/organizer/application-settings/{mobile-app-id}/supported-languages

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/application-settings/{mobile-app-id}/supported-languages"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        
        try {
            array['String'] result = apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdSupportedLanguagesGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        
        try {
            array['String'] result = apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerApplicationSettingsMobileAppIdSupportedLanguagesGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *mobileAppId = mobileAppId_example; //  (default to null)

[apiInstance organizerApplicationSettingsMobileAppIdSupportedLanguagesGetWith:mobileAppId
              completionHandler: ^(array['String'] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var mobileAppId = mobileAppId_example; // {String} 

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

namespace Example
{
    public class organizerApplicationSettingsMobileAppIdSupportedLanguagesGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)

            try {
                array['String'] result = apiInstance.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet(mobileAppId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerApplicationSettingsMobileAppIdSupportedLanguagesGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
mobileAppId = mobileAppId_example # String |  (default to null)

try: 
    api_response = api_instance.organizer_application_settings_mobile_app_id_supported_languages_get(mobileAppId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerApplicationSettingsMobileAppIdSupportedLanguagesGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let mobileAppId = mobileAppId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
mobile-app-id*
String
Required

Responses


organizerCommunicationsGet

Get the communication logs for the caller (organizer)


/organizer/communications

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/communications?limit=&offset=&email=&phoneNumber=&type=&status=&from=&to="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String offset = offset_example; // String | 
        String email = email_example; // String | 
        String phoneNumber = phoneNumber_example; // String | 
        String type = type_example; // String | 
        String status = status_example; // String | 
        String from = from_example; // String | 
        String to = to_example; // String | 
        
        try {
            OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, phoneNumber, type, status, from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String offset = offset_example; // String | 
        String email = email_example; // String | 
        String phoneNumber = phoneNumber_example; // String | 
        String type = type_example; // String | 
        String status = status_example; // String | 
        String from = from_example; // String | 
        String to = to_example; // String | 
        
        try {
            OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, phoneNumber, type, status, from, to);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerCommunicationsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *limit = limit_example; //  (default to null)
String *offset = offset_example; //  (default to null)
String *email = email_example; //  (optional) (default to null)
String *phoneNumber = phoneNumber_example; //  (optional) (default to null)
String *type = type_example; //  (optional) (default to null)
String *status = status_example; //  (optional) (default to null)
String *from = from_example; //  (optional) (default to null)
String *to = to_example; //  (optional) (default to null)

[apiInstance organizerCommunicationsGetWith:limit
    offset:offset
    email:email
    phoneNumber:phoneNumber
    type:type
    status:status
    from:from
    to:to
              completionHandler: ^(OrganizerCommunicationLogsSearchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var limit = limit_example; // {String} 
var offset = offset_example; // {String} 
var opts = {
  'email': email_example, // {String} 
  'phoneNumber': phoneNumber_example, // {String} 
  'type': type_example, // {String} 
  'status': status_example, // {String} 
  'from': from_example, // {String} 
  'to': to_example // {String} 
};

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

namespace Example
{
    public class organizerCommunicationsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = limit_example;  // String |  (default to null)
            var offset = offset_example;  // String |  (default to null)
            var email = email_example;  // String |  (optional)  (default to null)
            var phoneNumber = phoneNumber_example;  // String |  (optional)  (default to null)
            var type = type_example;  // String |  (optional)  (default to null)
            var status = status_example;  // String |  (optional)  (default to null)
            var from = from_example;  // String |  (optional)  (default to null)
            var to = to_example;  // String |  (optional)  (default to null)

            try {
                OrganizerCommunicationLogsSearchResponse result = apiInstance.organizerCommunicationsGet(limit, offset, email, phoneNumber, type, status, from, to);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerCommunicationsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$limit = limit_example; // String | 
$offset = offset_example; // String | 
$email = email_example; // String | 
$phoneNumber = phoneNumber_example; // String | 
$type = type_example; // String | 
$status = status_example; // String | 
$from = from_example; // String | 
$to = to_example; // String | 

try {
    $result = $api_instance->organizerCommunicationsGet($limit, $offset, $email, $phoneNumber, $type, $status, $from, $to);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerCommunicationsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $limit = limit_example; # String | 
my $offset = offset_example; # String | 
my $email = email_example; # String | 
my $phoneNumber = phoneNumber_example; # String | 
my $type = type_example; # String | 
my $status = status_example; # String | 
my $from = from_example; # String | 
my $to = to_example; # String | 

eval { 
    my $result = $api_instance->organizerCommunicationsGet(limit => $limit, offset => $offset, email => $email, phoneNumber => $phoneNumber, type => $type, status => $status, from => $from, to => $to);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerCommunicationsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
limit = limit_example # String |  (default to null)
offset = offset_example # String |  (default to null)
email = email_example # String |  (optional) (default to null)
phoneNumber = phoneNumber_example # String |  (optional) (default to null)
type = type_example # String |  (optional) (default to null)
status = status_example # String |  (optional) (default to null)
from = from_example # String |  (optional) (default to null)
to = to_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_communications_get(limit, offset, email=email, phoneNumber=phoneNumber, type=type, status=status, from=from, to=to)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerCommunicationsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let limit = limit_example; // String
    let offset = offset_example; // String
    let email = email_example; // String
    let phoneNumber = phoneNumber_example; // String
    let type = type_example; // String
    let status = status_example; // String
    let from = from_example; // String
    let to = to_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerCommunicationsGet(limit, offset, email, phoneNumber, type, status, from, to, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
limit*
String
Required
offset*
String
Required
email
String
phoneNumber
String
type
String
status
String
from
String
to
String

Responses


organizerConfigGet

[PUBLIC] Get the initial configuration necessary for an operator to begin the authentication process


/organizer/config

Usage and SDK Samples

curl -X GET\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/config"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerConfig result = apiInstance.organizerConfigGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerConfigGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            OrganizerConfig result = apiInstance.organizerConfigGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerConfigGet");
            e.printStackTrace();
        }
    }
}


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

[apiInstance organizerConfigGetWithCompletionHandler: 
              ^(OrganizerConfig output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');

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

namespace Example
{
    public class organizerConfigGetExample
    {
        public void main()
        {
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                OrganizerConfig result = apiInstance.organizerConfigGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerConfigGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerEventsAllGet

Get the list of events of the caller (organizer) without paging


/organizer/events/all

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/all"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsAllGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsAllGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


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

[apiInstance organizerEventsAllGetWithCompletionHandler: 
              ^(array[OrganizerAllEventsResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

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

namespace Example
{
    public class organizerEventsAllGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                array[OrganizerAllEventsResponse] result = apiInstance.organizerEventsAllGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsAllGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerEventsEventIdActivationIdPatch

Update the activation information of a sub group of tickets sharing the same eventId and activationId. This path ensure that the tickets keep coherent data between them


/organizer/events/{eventId}/{activationId}

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/{activationId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String activationId = activationId_example; // String | 
        String eventId = eventId_example; // String | 
        OrganizerTicketActivationPatch organizerTicketActivationPatch = ; // OrganizerTicketActivationPatch | 
        
        try {
            apiInstance.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdActivationIdPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String activationId = activationId_example; // String | 
        String eventId = eventId_example; // String | 
        OrganizerTicketActivationPatch organizerTicketActivationPatch = ; // OrganizerTicketActivationPatch | 
        
        try {
            apiInstance.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdActivationIdPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *activationId = activationId_example; //  (default to null)
String *eventId = eventId_example; //  (default to null)
OrganizerTicketActivationPatch *organizerTicketActivationPatch = ; // 

[apiInstance organizerEventsEventIdActivationIdPatchWith:activationId
    eventId:eventId
    organizerTicketActivationPatch:organizerTicketActivationPatch
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var activationId = activationId_example; // {String} 
var eventId = eventId_example; // {String} 
var organizerTicketActivationPatch = ; // {OrganizerTicketActivationPatch} 

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

namespace Example
{
    public class organizerEventsEventIdActivationIdPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var activationId = activationId_example;  // String |  (default to null)
            var eventId = eventId_example;  // String |  (default to null)
            var organizerTicketActivationPatch = new OrganizerTicketActivationPatch(); // OrganizerTicketActivationPatch | 

            try {
                apiInstance.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdActivationIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$activationId = activationId_example; // String | 
$eventId = eventId_example; // String | 
$organizerTicketActivationPatch = ; // OrganizerTicketActivationPatch | 

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $activationId = activationId_example; # String | 
my $eventId = eventId_example; # String | 
my $organizerTicketActivationPatch = WWW::OPenAPIClient::Object::OrganizerTicketActivationPatch->new(); # OrganizerTicketActivationPatch | 

eval { 
    $api_instance->organizerEventsEventIdActivationIdPatch(activationId => $activationId, eventId => $eventId, organizerTicketActivationPatch => $organizerTicketActivationPatch);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdActivationIdPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
activationId = activationId_example # String |  (default to null)
eventId = eventId_example # String |  (default to null)
organizerTicketActivationPatch =  # OrganizerTicketActivationPatch | 

try: 
    api_instance.organizer_events_event_id_activation_id_patch(activationId, eventId, organizerTicketActivationPatch)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdActivationIdPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let activationId = activationId_example; // String
    let eventId = eventId_example; // String
    let organizerTicketActivationPatch = ; // OrganizerTicketActivationPatch

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdActivationIdPatch(activationId, eventId, organizerTicketActivationPatch, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
activationId*
String
Required
eventId*
String
Required
Body parameters
Name Description
organizerTicketActivationPatch *

Responses


organizerEventsEventIdChartsGet

Get chart of tickets flows for the given event


/organizer/events/{eventId}/charts

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/charts"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        
        try {
            OrganizerEventChart result = apiInstance.organizerEventsEventIdChartsGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdChartsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        
        try {
            OrganizerEventChart result = apiInstance.organizerEventsEventIdChartsGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdChartsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = tixngo-league; // event id for the given event (default to null)

[apiInstance organizerEventsEventIdChartsGetWith:eventId
              completionHandler: ^(OrganizerEventChart output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event

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

namespace Example
{
    public class organizerEventsEventIdChartsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)

            try {
                OrganizerEventChart result = apiInstance.organizerEventsEventIdChartsGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdChartsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = tixngo-league # String | event id for the given event (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_charts_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdChartsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required

Responses


organizerEventsEventIdDesignsGet

Get designs for the given event


/organizer/events/{eventId}/designs

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/designs"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | event id for the given event
        
        try {
            OrganizerEventDesignResponse result = apiInstance.organizerEventsEventIdDesignsGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdDesignsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | event id for the given event
        
        try {
            OrganizerEventDesignResponse result = apiInstance.organizerEventsEventIdDesignsGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdDesignsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = eventId_example; // event id for the given event (default to null)

[apiInstance organizerEventsEventIdDesignsGetWith:eventId
              completionHandler: ^(OrganizerEventDesignResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = eventId_example; // {String} event id for the given event

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

namespace Example
{
    public class organizerEventsEventIdDesignsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String | event id for the given event (default to null)

            try {
                OrganizerEventDesignResponse result = apiInstance.organizerEventsEventIdDesignsGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdDesignsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = eventId_example; // String | event id for the given event

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = eventId_example; # String | event id for the given event

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = eventId_example # String | event id for the given event (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_designs_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdDesignsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required

Responses


organizerEventsEventIdGet

Get information about a single event


/organizer/events/{eventId}

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        
        try {
            OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        
        try {
            OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = eventId_example; //  (default to null)

[apiInstance organizerEventsEventIdGetWith:eventId
              completionHandler: ^(OrganizerEventsGetResponseEntry output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = eventId_example; // {String} 

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

namespace Example
{
    public class organizerEventsEventIdGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)

            try {
                OrganizerEventsGetResponseEntry result = apiInstance.organizerEventsEventIdGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = eventId_example # String |  (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
Required

Responses


organizerEventsEventIdPatch

Update information about an event, possibility to notify spectators.


/organizer/events/{eventId}

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}?mustNotifySpectator="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        OrganizerEventPatch organizerEventPatch = ; // OrganizerEventPatch | 
        String mustNotifySpectator = mustNotifySpectator_example; // String | 
        
        try {
            apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = eventId_example; // String | 
        OrganizerEventPatch organizerEventPatch = ; // OrganizerEventPatch | 
        String mustNotifySpectator = mustNotifySpectator_example; // String | 
        
        try {
            apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = eventId_example; //  (default to null)
OrganizerEventPatch *organizerEventPatch = ; // 
String *mustNotifySpectator = mustNotifySpectator_example; //  (optional) (default to null)

[apiInstance organizerEventsEventIdPatchWith:eventId
    organizerEventPatch:organizerEventPatch
    mustNotifySpectator:mustNotifySpectator
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = eventId_example; // {String} 
var organizerEventPatch = ; // {OrganizerEventPatch} 
var opts = {
  'mustNotifySpectator': mustNotifySpectator_example // {String} 
};

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

namespace Example
{
    public class organizerEventsEventIdPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = eventId_example;  // String |  (default to null)
            var organizerEventPatch = new OrganizerEventPatch(); // OrganizerEventPatch | 
            var mustNotifySpectator = mustNotifySpectator_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = eventId_example; // String | 
$organizerEventPatch = ; // OrganizerEventPatch | 
$mustNotifySpectator = mustNotifySpectator_example; // String | 

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = eventId_example; # String | 
my $organizerEventPatch = WWW::OPenAPIClient::Object::OrganizerEventPatch->new(); # OrganizerEventPatch | 
my $mustNotifySpectator = mustNotifySpectator_example; # String | 

eval { 
    $api_instance->organizerEventsEventIdPatch(eventId => $eventId, organizerEventPatch => $organizerEventPatch, mustNotifySpectator => $mustNotifySpectator);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = eventId_example # String |  (default to null)
organizerEventPatch =  # OrganizerEventPatch | 
mustNotifySpectator = mustNotifySpectator_example # String |  (optional) (default to null)

try: 
    api_instance.organizer_events_event_id_patch(eventId, organizerEventPatch, mustNotifySpectator=mustNotifySpectator)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = eventId_example; // String
    let organizerEventPatch = ; // OrganizerEventPatch
    let mustNotifySpectator = mustNotifySpectator_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdPatch(eventId, organizerEventPatch, mustNotifySpectator, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
Required
Body parameters
Name Description
organizerEventPatch *

Query parameters
Name Description
mustNotifySpectator
String

Responses


organizerEventsEventIdQuestionnaireDelete

Delete event health question


/organizer/events/{eventId}/questionnaire

Usage and SDK Samples

curl -X DELETE\
-H "x-api-key: [[apiKey]]"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/questionnaire?questionId="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        Long questionId = 789; // Long | question id of question to delete
        
        try {
            apiInstance.organizerEventsEventIdQuestionnaireDelete(eventId, questionId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireDelete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        Long questionId = 789; // Long | question id of question to delete
        
        try {
            apiInstance.organizerEventsEventIdQuestionnaireDelete(eventId, questionId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = tixngo-league; // event id for the given event (default to null)
Long *questionId = 789; // question id of question to delete (default to null)

[apiInstance organizerEventsEventIdQuestionnaireDeleteWith:eventId
    questionId:questionId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event
var questionId = 789; // {Long} question id of question to delete

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

namespace Example
{
    public class organizerEventsEventIdQuestionnaireDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)
            var questionId = 789;  // Long | question id of question to delete (default to null)

            try {
                apiInstance.organizerEventsEventIdQuestionnaireDelete(eventId, questionId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdQuestionnaireDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event
$questionId = 789; // Long | question id of question to delete

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event
my $questionId = 789; # Long | question id of question to delete

eval { 
    $api_instance->organizerEventsEventIdQuestionnaireDelete(eventId => $eventId, questionId => $questionId);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireDelete: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = tixngo-league # String | event id for the given event (default to null)
questionId = 789 # Long | question id of question to delete (default to null)

try: 
    api_instance.organizer_events_event_id_questionnaire_delete(eventId, questionId)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireDelete: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String
    let questionId = 789; // Long

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdQuestionnaireDelete(eventId, questionId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required
Query parameters
Name Description
questionId*
Long (int64)
question id of question to delete
Required

Responses


organizerEventsEventIdQuestionnaireGet

Get health questionnaire for the given event


/organizer/events/{eventId}/questionnaire

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/questionnaire"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        
        try {
            EventQuestionnaireResponse result = apiInstance.organizerEventsEventIdQuestionnaireGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        
        try {
            EventQuestionnaireResponse result = apiInstance.organizerEventsEventIdQuestionnaireGet(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnaireGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = tixngo-league; // event id for the given event (default to null)

[apiInstance organizerEventsEventIdQuestionnaireGetWith:eventId
              completionHandler: ^(EventQuestionnaireResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event

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

namespace Example
{
    public class organizerEventsEventIdQuestionnaireGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)

            try {
                EventQuestionnaireResponse result = apiInstance.organizerEventsEventIdQuestionnaireGet(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdQuestionnaireGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = tixngo-league # String | event id for the given event (default to null)

try: 
    api_response = api_instance.organizer_events_event_id_questionnaire_get(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdQuestionnaireGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String

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

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required

Responses


organizerEventsEventIdQuestionnairePatch

Update event health questionnaire


/organizer/events/{eventId}/questionnaire

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/questionnaire"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        EventQuestionnairePatchRequest eventQuestionnairePatchRequest = ; // EventQuestionnairePatchRequest | 
        
        try {
            EventQuestionnaireResponse result = apiInstance.organizerEventsEventIdQuestionnairePatch(eventId, eventQuestionnairePatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnairePatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        EventQuestionnairePatchRequest eventQuestionnairePatchRequest = ; // EventQuestionnairePatchRequest | 
        
        try {
            EventQuestionnaireResponse result = apiInstance.organizerEventsEventIdQuestionnairePatch(eventId, eventQuestionnairePatchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdQuestionnairePatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = tixngo-league; // event id for the given event (default to null)
EventQuestionnairePatchRequest *eventQuestionnairePatchRequest = ; // 

[apiInstance organizerEventsEventIdQuestionnairePatchWith:eventId
    eventQuestionnairePatchRequest:eventQuestionnairePatchRequest
              completionHandler: ^(EventQuestionnaireResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event
var eventQuestionnairePatchRequest = ; // {EventQuestionnairePatchRequest} 

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

namespace Example
{
    public class organizerEventsEventIdQuestionnairePatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)
            var eventQuestionnairePatchRequest = new EventQuestionnairePatchRequest(); // EventQuestionnairePatchRequest | 

            try {
                EventQuestionnaireResponse result = apiInstance.organizerEventsEventIdQuestionnairePatch(eventId, eventQuestionnairePatchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdQuestionnairePatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event
$eventQuestionnairePatchRequest = ; // EventQuestionnairePatchRequest | 

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event
my $eventQuestionnairePatchRequest = WWW::OPenAPIClient::Object::EventQuestionnairePatchRequest->new(); # EventQuestionnairePatchRequest | 

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = tixngo-league # String | event id for the given event (default to null)
eventQuestionnairePatchRequest =  # EventQuestionnairePatchRequest | 

try: 
    api_response = api_instance.organizer_events_event_id_questionnaire_patch(eventId, eventQuestionnairePatchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdQuestionnairePatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String
    let eventQuestionnairePatchRequest = ; // EventQuestionnairePatchRequest

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdQuestionnairePatch(eventId, eventQuestionnairePatchRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required
Body parameters
Name Description
eventQuestionnairePatchRequest *

Responses


organizerEventsEventIdTicketsPatch

Update event information and some fields of tickets belonging to this event, possibility to notify spectators.


/organizer/events/{eventId}/tickets

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/events/{eventId}/tickets?transferRulesId=&mustNotifySpectator="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        OrganizerEventDetailsRequest organizerEventDetailsRequest = ; // OrganizerEventDetailsRequest | 
        String transferRulesId = transferRulesId_example; // String | transfer rules id targets tickets to update, if null all tickets
        String mustNotifySpectator = mustNotifySpectator_example; // String | 
        
        try {
            apiInstance.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdTicketsPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String eventId = tixngo-league; // String | event id for the given event
        OrganizerEventDetailsRequest organizerEventDetailsRequest = ; // OrganizerEventDetailsRequest | 
        String transferRulesId = transferRulesId_example; // String | transfer rules id targets tickets to update, if null all tickets
        String mustNotifySpectator = mustNotifySpectator_example; // String | 
        
        try {
            apiInstance.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsEventIdTicketsPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *eventId = tixngo-league; // event id for the given event (default to null)
OrganizerEventDetailsRequest *organizerEventDetailsRequest = ; // 
String *transferRulesId = transferRulesId_example; // transfer rules id targets tickets to update, if null all tickets (optional) (default to null)
String *mustNotifySpectator = mustNotifySpectator_example; //  (optional) (default to null)

[apiInstance organizerEventsEventIdTicketsPatchWith:eventId
    organizerEventDetailsRequest:organizerEventDetailsRequest
    transferRulesId:transferRulesId
    mustNotifySpectator:mustNotifySpectator
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var eventId = tixngo-league; // {String} event id for the given event
var organizerEventDetailsRequest = ; // {OrganizerEventDetailsRequest} 
var opts = {
  'transferRulesId': transferRulesId_example, // {String} transfer rules id targets tickets to update, if null all tickets
  'mustNotifySpectator': mustNotifySpectator_example // {String} 
};

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

namespace Example
{
    public class organizerEventsEventIdTicketsPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var eventId = tixngo-league;  // String | event id for the given event (default to null)
            var organizerEventDetailsRequest = new OrganizerEventDetailsRequest(); // OrganizerEventDetailsRequest | 
            var transferRulesId = transferRulesId_example;  // String | transfer rules id targets tickets to update, if null all tickets (optional)  (default to null)
            var mustNotifySpectator = mustNotifySpectator_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsEventIdTicketsPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$eventId = tixngo-league; // String | event id for the given event
$organizerEventDetailsRequest = ; // OrganizerEventDetailsRequest | 
$transferRulesId = transferRulesId_example; // String | transfer rules id targets tickets to update, if null all tickets
$mustNotifySpectator = mustNotifySpectator_example; // String | 

try {
    $api_instance->organizerEventsEventIdTicketsPatch($eventId, $organizerEventDetailsRequest, $transferRulesId, $mustNotifySpectator);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsEventIdTicketsPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $eventId = tixngo-league; # String | event id for the given event
my $organizerEventDetailsRequest = WWW::OPenAPIClient::Object::OrganizerEventDetailsRequest->new(); # OrganizerEventDetailsRequest | 
my $transferRulesId = transferRulesId_example; # String | transfer rules id targets tickets to update, if null all tickets
my $mustNotifySpectator = mustNotifySpectator_example; # String | 

eval { 
    $api_instance->organizerEventsEventIdTicketsPatch(eventId => $eventId, organizerEventDetailsRequest => $organizerEventDetailsRequest, transferRulesId => $transferRulesId, mustNotifySpectator => $mustNotifySpectator);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsEventIdTicketsPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
eventId = tixngo-league # String | event id for the given event (default to null)
organizerEventDetailsRequest =  # OrganizerEventDetailsRequest | 
transferRulesId = transferRulesId_example # String | transfer rules id targets tickets to update, if null all tickets (optional) (default to null)
mustNotifySpectator = mustNotifySpectator_example # String |  (optional) (default to null)

try: 
    api_instance.organizer_events_event_id_tickets_patch(eventId, organizerEventDetailsRequest, transferRulesId=transferRulesId, mustNotifySpectator=mustNotifySpectator)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsEventIdTicketsPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let eventId = tixngo-league; // String
    let organizerEventDetailsRequest = ; // OrganizerEventDetailsRequest
    let transferRulesId = transferRulesId_example; // String
    let mustNotifySpectator = mustNotifySpectator_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsEventIdTicketsPatch(eventId, organizerEventDetailsRequest, transferRulesId, mustNotifySpectator, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
eventId*
String
event id for the given event
Required
Body parameters
Name Description
organizerEventDetailsRequest *

Query parameters
Name Description
transferRulesId
String
transfer rules id targets tickets to update, if null all tickets
mustNotifySpectator
String

Responses


organizerEventsGet

Get the list of events of the caller (organizer)


/organizer/events

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/events?offset=&limit=&eventName=&eventId=&startDate="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String eventName = eventName_example; // String | 
        String eventId = eventId_example; // String | 
        date startDate = Thu Feb 20 00:00:00 GMT 2020; // date | 
        
        try {
            OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, startDate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String offset = offset_example; // String | 
        String limit = limit_example; // String | 
        String eventName = eventName_example; // String | 
        String eventId = eventId_example; // String | 
        date startDate = Thu Feb 20 00:00:00 GMT 2020; // date | 
        
        try {
            OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, startDate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerEventsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *offset = offset_example; //  (default to null)
String *limit = limit_example; //  (default to null)
String *eventName = eventName_example; //  (optional) (default to null)
String *eventId = eventId_example; //  (optional) (default to null)
date *startDate = Thu Feb 20 00:00:00 GMT 2020; //  (optional) (default to null)

[apiInstance organizerEventsGetWith:offset
    limit:limit
    eventName:eventName
    eventId:eventId
    startDate:startDate
              completionHandler: ^(OrganizerEventsGetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var offset = offset_example; // {String} 
var limit = limit_example; // {String} 
var opts = {
  'eventName': eventName_example, // {String} 
  'eventId': eventId_example, // {String} 
  'startDate': Thu Feb 20 00:00:00 GMT 2020 // {date} 
};

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

namespace Example
{
    public class organizerEventsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var offset = offset_example;  // String |  (default to null)
            var limit = limit_example;  // String |  (default to null)
            var eventName = eventName_example;  // String |  (optional)  (default to null)
            var eventId = eventId_example;  // String |  (optional)  (default to null)
            var startDate = Thu Feb 20 00:00:00 GMT 2020;  // date |  (optional)  (default to null)

            try {
                OrganizerEventsGetResponse result = apiInstance.organizerEventsGet(offset, limit, eventName, eventId, startDate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerEventsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$offset = offset_example; // String | 
$limit = limit_example; // String | 
$eventName = eventName_example; // String | 
$eventId = eventId_example; // String | 
$startDate = Thu Feb 20 00:00:00 GMT 2020; // date | 

try {
    $result = $api_instance->organizerEventsGet($offset, $limit, $eventName, $eventId, $startDate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerEventsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $offset = offset_example; # String | 
my $limit = limit_example; # String | 
my $eventName = eventName_example; # String | 
my $eventId = eventId_example; # String | 
my $startDate = Thu Feb 20 00:00:00 GMT 2020; # date | 

eval { 
    my $result = $api_instance->organizerEventsGet(offset => $offset, limit => $limit, eventName => $eventName, eventId => $eventId, startDate => $startDate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerEventsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
offset = offset_example # String |  (default to null)
limit = limit_example # String |  (default to null)
eventName = eventName_example # String |  (optional) (default to null)
eventId = eventId_example # String |  (optional) (default to null)
startDate = Thu Feb 20 00:00:00 GMT 2020 # date |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_events_get(offset, limit, eventName=eventName, eventId=eventId, startDate=startDate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerEventsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let offset = offset_example; // String
    let limit = limit_example; // String
    let eventName = eventName_example; // String
    let eventId = eventId_example; // String
    let startDate = Thu Feb 20 00:00:00 GMT 2020; // date

    let mut context = DefaultApi::Context::default();
    let result = client.organizerEventsGet(offset, limit, eventName, eventId, startDate, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
offset*
String
Required
limit*
String
Required
eventName
String
eventId
String
startDate
date (date)

Responses


organizerGroupsGroupIdPatch

Update information for a single group. Ensure that all tickets of the group are updated in a coherent way


/organizer/groups/{groupId}

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/groups/{groupId}?mustNotifySpectator="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String groupId = groupId_example; // String | 
        OrganizerEditableTicketGroup organizerEditableTicketGroup = ; // OrganizerEditableTicketGroup | 
        String mustNotifySpectator = mustNotifySpectator_example; // String | 
        
        try {
            apiInstance.organizerGroupsGroupIdPatch(groupId, organizerEditableTicketGroup, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerGroupsGroupIdPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String groupId = groupId_example; // String | 
        OrganizerEditableTicketGroup organizerEditableTicketGroup = ; // OrganizerEditableTicketGroup | 
        String mustNotifySpectator = mustNotifySpectator_example; // String | 
        
        try {
            apiInstance.organizerGroupsGroupIdPatch(groupId, organizerEditableTicketGroup, mustNotifySpectator);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerGroupsGroupIdPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *groupId = groupId_example; //  (default to null)
OrganizerEditableTicketGroup *organizerEditableTicketGroup = ; // 
String *mustNotifySpectator = mustNotifySpectator_example; //  (optional) (default to null)

[apiInstance organizerGroupsGroupIdPatchWith:groupId
    organizerEditableTicketGroup:organizerEditableTicketGroup
    mustNotifySpectator:mustNotifySpectator
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var groupId = groupId_example; // {String} 
var organizerEditableTicketGroup = ; // {OrganizerEditableTicketGroup} 
var opts = {
  'mustNotifySpectator': mustNotifySpectator_example // {String} 
};

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

namespace Example
{
    public class organizerGroupsGroupIdPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var groupId = groupId_example;  // String |  (default to null)
            var organizerEditableTicketGroup = new OrganizerEditableTicketGroup(); // OrganizerEditableTicketGroup | 
            var mustNotifySpectator = mustNotifySpectator_example;  // String |  (optional)  (default to null)

            try {
                apiInstance.organizerGroupsGroupIdPatch(groupId, organizerEditableTicketGroup, mustNotifySpectator);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerGroupsGroupIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$groupId = groupId_example; // String | 
$organizerEditableTicketGroup = ; // OrganizerEditableTicketGroup | 
$mustNotifySpectator = mustNotifySpectator_example; // String | 

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $groupId = groupId_example; # String | 
my $organizerEditableTicketGroup = WWW::OPenAPIClient::Object::OrganizerEditableTicketGroup->new(); # OrganizerEditableTicketGroup | 
my $mustNotifySpectator = mustNotifySpectator_example; # String | 

eval { 
    $api_instance->organizerGroupsGroupIdPatch(groupId => $groupId, organizerEditableTicketGroup => $organizerEditableTicketGroup, mustNotifySpectator => $mustNotifySpectator);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerGroupsGroupIdPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
groupId = groupId_example # String |  (default to null)
organizerEditableTicketGroup =  # OrganizerEditableTicketGroup | 
mustNotifySpectator = mustNotifySpectator_example # String |  (optional) (default to null)

try: 
    api_instance.organizer_groups_group_id_patch(groupId, organizerEditableTicketGroup, mustNotifySpectator=mustNotifySpectator)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerGroupsGroupIdPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let groupId = groupId_example; // String
    let organizerEditableTicketGroup = ; // OrganizerEditableTicketGroup
    let mustNotifySpectator = mustNotifySpectator_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerGroupsGroupIdPatch(groupId, organizerEditableTicketGroup, mustNotifySpectator, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
groupId*
String
Required
Body parameters
Name Description
organizerEditableTicketGroup *

Query parameters
Name Description
mustNotifySpectator
String

Responses


organizerMobileAppIdSettingsKeyPatch

Modify the setting for the application if the setting is not readonly


/organizer/{mobile-app-id}/settings/{key}

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/{mobile-app-id}/settings/{key}?oldValue="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String key = key_example; // String | 
        String oldValue = oldValue_example; // String | 
        ApplicationEditableSetting applicationEditableSetting = ; // ApplicationEditableSetting | 
        
        try {
            apiInstance.organizerMobileAppIdSettingsKeyPatch(mobileAppId, key, oldValue, applicationEditableSetting);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerMobileAppIdSettingsKeyPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String key = key_example; // String | 
        String oldValue = oldValue_example; // String | 
        ApplicationEditableSetting applicationEditableSetting = ; // ApplicationEditableSetting | 
        
        try {
            apiInstance.organizerMobileAppIdSettingsKeyPatch(mobileAppId, key, oldValue, applicationEditableSetting);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerMobileAppIdSettingsKeyPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *mobileAppId = mobileAppId_example; //  (default to null)
String *key = key_example; //  (default to null)
String *oldValue = oldValue_example; //  (optional) (default to null)
ApplicationEditableSetting *applicationEditableSetting = ; //  (optional)

[apiInstance organizerMobileAppIdSettingsKeyPatchWith:mobileAppId
    key:key
    oldValue:oldValue
    applicationEditableSetting:applicationEditableSetting
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var mobileAppId = mobileAppId_example; // {String} 
var key = key_example; // {String} 
var opts = {
  'oldValue': oldValue_example, // {String} 
  'applicationEditableSetting':  // {ApplicationEditableSetting} 
};

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

namespace Example
{
    public class organizerMobileAppIdSettingsKeyPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)
            var key = key_example;  // String |  (default to null)
            var oldValue = oldValue_example;  // String |  (optional)  (default to null)
            var applicationEditableSetting = new ApplicationEditableSetting(); // ApplicationEditableSetting |  (optional) 

            try {
                apiInstance.organizerMobileAppIdSettingsKeyPatch(mobileAppId, key, oldValue, applicationEditableSetting);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerMobileAppIdSettingsKeyPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mobileAppId = mobileAppId_example; // String | 
$key = key_example; // String | 
$oldValue = oldValue_example; // String | 
$applicationEditableSetting = ; // ApplicationEditableSetting | 

try {
    $api_instance->organizerMobileAppIdSettingsKeyPatch($mobileAppId, $key, $oldValue, $applicationEditableSetting);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerMobileAppIdSettingsKeyPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $mobileAppId = mobileAppId_example; # String | 
my $key = key_example; # String | 
my $oldValue = oldValue_example; # String | 
my $applicationEditableSetting = WWW::OPenAPIClient::Object::ApplicationEditableSetting->new(); # ApplicationEditableSetting | 

eval { 
    $api_instance->organizerMobileAppIdSettingsKeyPatch(mobileAppId => $mobileAppId, key => $key, oldValue => $oldValue, applicationEditableSetting => $applicationEditableSetting);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerMobileAppIdSettingsKeyPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
mobileAppId = mobileAppId_example # String |  (default to null)
key = key_example # String |  (default to null)
oldValue = oldValue_example # String |  (optional) (default to null)
applicationEditableSetting =  # ApplicationEditableSetting |  (optional)

try: 
    api_instance.organizer_mobile_app_id_settings_key_patch(mobileAppId, key, oldValue=oldValue, applicationEditableSetting=applicationEditableSetting)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerMobileAppIdSettingsKeyPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let mobileAppId = mobileAppId_example; // String
    let key = key_example; // String
    let oldValue = oldValue_example; // String
    let applicationEditableSetting = ; // ApplicationEditableSetting

    let mut context = DefaultApi::Context::default();
    let result = client.organizerMobileAppIdSettingsKeyPatch(mobileAppId, key, oldValue, applicationEditableSetting, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
mobile-app-id*
String
Required
key*
String
Required
Body parameters
Name Description
applicationEditableSetting

Query parameters
Name Description
oldValue
String

Responses


organizerMobilelogsGet

Get the mobile logs for the caller (organizer). Mobile logs are sent by the mobile application to the TIXnGO system.


/organizer/mobilelogs

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/mobilelogs?limit=&offset=&email=&os=&logLevel=&logType=&appName=&from=&to=&message="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | Set the number of results returned.
        String offset = offset_example; // String | Specify the offset of the first hit to return.
        String email = email_example; // String | 
        String os = os_example; // String | 
        String logLevel = logLevel_example; // String | 
        String logType = logType_example; // String | 
        String appName = appName_example; // String | 
        String from = from_example; // String | 
        String to = to_example; // String | 
        String message = message_example; // String | 
        
        try {
            OrganizerMobileLogsSearchResponse result = apiInstance.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerMobilelogsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | Set the number of results returned.
        String offset = offset_example; // String | Specify the offset of the first hit to return.
        String email = email_example; // String | 
        String os = os_example; // String | 
        String logLevel = logLevel_example; // String | 
        String logType = logType_example; // String | 
        String appName = appName_example; // String | 
        String from = from_example; // String | 
        String to = to_example; // String | 
        String message = message_example; // String | 
        
        try {
            OrganizerMobileLogsSearchResponse result = apiInstance.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerMobilelogsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *limit = limit_example; // Set the number of results returned. (default to null)
String *offset = offset_example; // Specify the offset of the first hit to return. (default to null)
String *email = email_example; //  (optional) (default to null)
String *os = os_example; //  (optional) (default to null)
String *logLevel = logLevel_example; //  (optional) (default to null)
String *logType = logType_example; //  (optional) (default to null)
String *appName = appName_example; //  (optional) (default to null)
String *from = from_example; //  (optional) (default to null)
String *to = to_example; //  (optional) (default to null)
String *message = message_example; //  (optional) (default to null)

[apiInstance organizerMobilelogsGetWith:limit
    offset:offset
    email:email
    os:os
    logLevel:logLevel
    logType:logType
    appName:appName
    from:from
    to:to
    message:message
              completionHandler: ^(OrganizerMobileLogsSearchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var limit = limit_example; // {String} Set the number of results returned.
var offset = offset_example; // {String} Specify the offset of the first hit to return.
var opts = {
  'email': email_example, // {String} 
  'os': os_example, // {String} 
  'logLevel': logLevel_example, // {String} 
  'logType': logType_example, // {String} 
  'appName': appName_example, // {String} 
  'from': from_example, // {String} 
  'to': to_example, // {String} 
  'message': message_example // {String} 
};

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

namespace Example
{
    public class organizerMobilelogsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = limit_example;  // String | Set the number of results returned. (default to null)
            var offset = offset_example;  // String | Specify the offset of the first hit to return. (default to null)
            var email = email_example;  // String |  (optional)  (default to null)
            var os = os_example;  // String |  (optional)  (default to null)
            var logLevel = logLevel_example;  // String |  (optional)  (default to null)
            var logType = logType_example;  // String |  (optional)  (default to null)
            var appName = appName_example;  // String |  (optional)  (default to null)
            var from = from_example;  // String |  (optional)  (default to null)
            var to = to_example;  // String |  (optional)  (default to null)
            var message = message_example;  // String |  (optional)  (default to null)

            try {
                OrganizerMobileLogsSearchResponse result = apiInstance.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerMobilelogsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$limit = limit_example; // String | Set the number of results returned.
$offset = offset_example; // String | Specify the offset of the first hit to return.
$email = email_example; // String | 
$os = os_example; // String | 
$logLevel = logLevel_example; // String | 
$logType = logType_example; // String | 
$appName = appName_example; // String | 
$from = from_example; // String | 
$to = to_example; // String | 
$message = message_example; // String | 

try {
    $result = $api_instance->organizerMobilelogsGet($limit, $offset, $email, $os, $logLevel, $logType, $appName, $from, $to, $message);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerMobilelogsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $limit = limit_example; # String | Set the number of results returned.
my $offset = offset_example; # String | Specify the offset of the first hit to return.
my $email = email_example; # String | 
my $os = os_example; # String | 
my $logLevel = logLevel_example; # String | 
my $logType = logType_example; # String | 
my $appName = appName_example; # String | 
my $from = from_example; # String | 
my $to = to_example; # String | 
my $message = message_example; # String | 

eval { 
    my $result = $api_instance->organizerMobilelogsGet(limit => $limit, offset => $offset, email => $email, os => $os, logLevel => $logLevel, logType => $logType, appName => $appName, from => $from, to => $to, message => $message);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerMobilelogsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
limit = limit_example # String | Set the number of results returned. (default to null)
offset = offset_example # String | Specify the offset of the first hit to return. (default to null)
email = email_example # String |  (optional) (default to null)
os = os_example # String |  (optional) (default to null)
logLevel = logLevel_example # String |  (optional) (default to null)
logType = logType_example # String |  (optional) (default to null)
appName = appName_example # String |  (optional) (default to null)
from = from_example # String |  (optional) (default to null)
to = to_example # String |  (optional) (default to null)
message = message_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_mobilelogs_get(limit, offset, email=email, os=os, logLevel=logLevel, logType=logType, appName=appName, from=from, to=to, message=message)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerMobilelogsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let limit = limit_example; // String
    let offset = offset_example; // String
    let email = email_example; // String
    let os = os_example; // String
    let logLevel = logLevel_example; // String
    let logType = logType_example; // String
    let appName = appName_example; // String
    let from = from_example; // String
    let to = to_example; // String
    let message = message_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerMobilelogsGet(limit, offset, email, os, logLevel, logType, appName, from, to, message, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
limit*
String
Set the number of results returned.
Required
offset*
String
Specify the offset of the first hit to return.
Required
email
String
os
String
logLevel
String
logType
String
appName
String
from
String
to
String
message
String

Responses


organizerNotificationcampaignPatch

Update a notification campaign, cancel or reschedule


/organizer/notificationcampaign

Usage and SDK Samples

curl -X PATCH\
-H "x-api-key: [[apiKey]]"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/notificationcampaign"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        OrganizerNotificationCampaign organizerNotificationCampaign = ; // OrganizerNotificationCampaign | 
        
        try {
            apiInstance.organizerNotificationcampaignPatch(organizerNotificationCampaign);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignPatch");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        OrganizerNotificationCampaign organizerNotificationCampaign = ; // OrganizerNotificationCampaign | 
        
        try {
            apiInstance.organizerNotificationcampaignPatch(organizerNotificationCampaign);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignPatch");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


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

[apiInstance organizerNotificationcampaignPatchWith:organizerNotificationCampaign
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var organizerNotificationCampaign = ; // {OrganizerNotificationCampaign} 

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

namespace Example
{
    public class organizerNotificationcampaignPatchExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var organizerNotificationCampaign = new OrganizerNotificationCampaign(); // OrganizerNotificationCampaign | 

            try {
                apiInstance.organizerNotificationcampaignPatch(organizerNotificationCampaign);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

eval { 
    $api_instance->organizerNotificationcampaignPatch(organizerNotificationCampaign => $organizerNotificationCampaign);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignPatch: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
organizerNotificationCampaign =  # OrganizerNotificationCampaign | 

try: 
    api_instance.organizer_notificationcampaign_patch(organizerNotificationCampaign)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerNotificationcampaignPatch: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let organizerNotificationCampaign = ; // OrganizerNotificationCampaign

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

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

Scopes

Parameters

Body parameters
Name Description
organizerNotificationCampaign *

Responses


organizerNotificationcampaignPost

Create a notification campaign that will target spectators of a certain event


/organizer/notificationcampaign

Usage and SDK Samples

curl -X POST\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer/notificationcampaign"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        OrganizerNotificationCampaign organizerNotificationCampaign = ; // OrganizerNotificationCampaign | 
        
        try {
            OrganizerNotificationCampaign result = apiInstance.organizerNotificationcampaignPost(organizerNotificationCampaign);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        OrganizerNotificationCampaign organizerNotificationCampaign = ; // OrganizerNotificationCampaign | 
        
        try {
            OrganizerNotificationCampaign result = apiInstance.organizerNotificationcampaignPost(organizerNotificationCampaign);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


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

[apiInstance organizerNotificationcampaignPostWith:organizerNotificationCampaign
              completionHandler: ^(OrganizerNotificationCampaign output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var organizerNotificationCampaign = ; // {OrganizerNotificationCampaign} 

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

namespace Example
{
    public class organizerNotificationcampaignPostExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var organizerNotificationCampaign = new OrganizerNotificationCampaign(); // OrganizerNotificationCampaign | 

            try {
                OrganizerNotificationCampaign result = apiInstance.organizerNotificationcampaignPost(organizerNotificationCampaign);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

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

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

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

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
organizerNotificationCampaign =  # OrganizerNotificationCampaign | 

try: 
    api_response = api_instance.organizer_notificationcampaign_post(organizerNotificationCampaign)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerNotificationcampaignPost: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let organizerNotificationCampaign = ; // OrganizerNotificationCampaign

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

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

Scopes

Parameters

Body parameters
Name Description
organizerNotificationCampaign *

Responses


organizerNotificationcampaignReportsGet

Used to retrieve the notification report of notification campaigns


/organizer/notificationcampaign/reports

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/notificationcampaign/reports?limit=&offset=&name=&contentLanguage="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String offset = offset_example; // String | 
        String name = name_example; // String | 
        String contentLanguage = contentLanguage_example; // String | 
        
        try {
            OrganizerNotificationCampaignReportResponse result = apiInstance.organizerNotificationcampaignReportsGet(limit, offset, name, contentLanguage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignReportsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | 
        String offset = offset_example; // String | 
        String name = name_example; // String | 
        String contentLanguage = contentLanguage_example; // String | 
        
        try {
            OrganizerNotificationCampaignReportResponse result = apiInstance.organizerNotificationcampaignReportsGet(limit, offset, name, contentLanguage);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignReportsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *limit = limit_example; //  (default to null)
String *offset = offset_example; //  (default to null)
String *name = name_example; //  (optional) (default to null)
String *contentLanguage = contentLanguage_example; //  (optional) (default to null)

[apiInstance organizerNotificationcampaignReportsGetWith:limit
    offset:offset
    name:name
    contentLanguage:contentLanguage
              completionHandler: ^(OrganizerNotificationCampaignReportResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var limit = limit_example; // {String} 
var offset = offset_example; // {String} 
var opts = {
  'name': name_example, // {String} 
  'contentLanguage': contentLanguage_example // {String} 
};

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

namespace Example
{
    public class organizerNotificationcampaignReportsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = limit_example;  // String |  (default to null)
            var offset = offset_example;  // String |  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)
            var contentLanguage = contentLanguage_example;  // String |  (optional)  (default to null)

            try {
                OrganizerNotificationCampaignReportResponse result = apiInstance.organizerNotificationcampaignReportsGet(limit, offset, name, contentLanguage);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignReportsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$limit = limit_example; // String | 
$offset = offset_example; // String | 
$name = name_example; // String | 
$contentLanguage = contentLanguage_example; // String | 

try {
    $result = $api_instance->organizerNotificationcampaignReportsGet($limit, $offset, $name, $contentLanguage);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerNotificationcampaignReportsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $limit = limit_example; # String | 
my $offset = offset_example; # String | 
my $name = name_example; # String | 
my $contentLanguage = contentLanguage_example; # String | 

eval { 
    my $result = $api_instance->organizerNotificationcampaignReportsGet(limit => $limit, offset => $offset, name => $name, contentLanguage => $contentLanguage);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerNotificationcampaignReportsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
limit = limit_example # String |  (default to null)
offset = offset_example # String |  (default to null)
name = name_example # String |  (optional) (default to null)
contentLanguage = contentLanguage_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_notificationcampaign_reports_get(limit, offset, name=name, contentLanguage=contentLanguage)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerNotificationcampaignReportsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let limit = limit_example; // String
    let offset = offset_example; // String
    let name = name_example; // String
    let contentLanguage = contentLanguage_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerNotificationcampaignReportsGet(limit, offset, name, contentLanguage, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
limit*
String
Required
offset*
String
Required
name
String
contentLanguage
String

Responses


organizerNotificationcampaignTargetsGet

Used to retrieve the amount of target spectator of notification campaigns


/organizer/notificationcampaign/targets

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/notificationcampaign/targets?eventId=&emails=&mobile-app-id="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String eventId = eventId_example; // String | 
        array[String] emails = ; // array[String] | 
        
        try {
            OrganizerNotificationCampaignTargetsResponse result = apiInstance.organizerNotificationcampaignTargetsGet(mobileAppId, eventId, emails);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignTargetsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String mobileAppId = mobileAppId_example; // String | 
        String eventId = eventId_example; // String | 
        array[String] emails = ; // array[String] | 
        
        try {
            OrganizerNotificationCampaignTargetsResponse result = apiInstance.organizerNotificationcampaignTargetsGet(mobileAppId, eventId, emails);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerNotificationcampaignTargetsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *mobileAppId = mobileAppId_example; //  (default to null)
String *eventId = eventId_example; //  (optional) (default to null)
array[String] *emails = ; //  (optional) (default to null)

[apiInstance organizerNotificationcampaignTargetsGetWith:mobileAppId
    eventId:eventId
    emails:emails
              completionHandler: ^(OrganizerNotificationCampaignTargetsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var mobileAppId = mobileAppId_example; // {String} 
var opts = {
  'eventId': eventId_example, // {String} 
  'emails':  // {array[String]} 
};

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

namespace Example
{
    public class organizerNotificationcampaignTargetsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mobileAppId = mobileAppId_example;  // String |  (default to null)
            var eventId = eventId_example;  // String |  (optional)  (default to null)
            var emails = new array[String](); // array[String] |  (optional)  (default to null)

            try {
                OrganizerNotificationCampaignTargetsResponse result = apiInstance.organizerNotificationcampaignTargetsGet(mobileAppId, eventId, emails);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerNotificationcampaignTargetsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mobileAppId = mobileAppId_example; // String | 
$eventId = eventId_example; // String | 
$emails = ; // array[String] | 

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

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $mobileAppId = mobileAppId_example; # String | 
my $eventId = eventId_example; # String | 
my $emails = []; # array[String] | 

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

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
mobileAppId = mobileAppId_example # String |  (default to null)
eventId = eventId_example # String |  (optional) (default to null)
emails =  # array[String] |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_notificationcampaign_targets_get(mobileAppId, eventId=eventId, emails=emails)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerNotificationcampaignTargetsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let mobileAppId = mobileAppId_example; // String
    let eventId = eventId_example; // String
    let emails = ; // array[String]

    let mut context = DefaultApi::Context::default();
    let result = client.organizerNotificationcampaignTargetsGet(mobileAppId, eventId, emails, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
eventId
String
emails
array[String]
mobile-app-id*
String
Required

Responses


organizerOperatorRoleGet

Retrieve the requester operator role


/organizer/operator/role

Usage and SDK Samples

curl -X GET\
-H "Authorization: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/operator/role"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: tyxr-organizers
        ApiKeyAuth tyxr-organizers = (ApiKeyAuth) defaultClient.getAuthentication("tyxr-organizers");
        tyxr-organizers.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //tyxr-organizers.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            'String' result = apiInstance.organizerOperatorRoleGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerOperatorRoleGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        
        try {
            'String' result = apiInstance.organizerOperatorRoleGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerOperatorRoleGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: tyxr-organizers)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


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

[apiInstance organizerOperatorRoleGetWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: tyxr-organizers
var tyxr-organizers = defaultClient.authentications['tyxr-organizers'];
tyxr-organizers.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//tyxr-organizers.apiKeyPrefix['Authorization'] = "Token";

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

namespace Example
{
    public class organizerOperatorRoleGetExample
    {
        public void main()
        {
            // Configure API key authorization: tyxr-organizers
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                'String' result = apiInstance.organizerOperatorRoleGet();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerOperatorRoleGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: tyxr-organizers
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

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

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

# Configure API key authorization: tyxr-organizers
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

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

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

# Configure API key authorization: tyxr-organizers
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses


organizerPendingSpectatorsGet

Get all pending/unconfirmed spectators to whom another spectator initiate a transfer


/organizer/pendingSpectators

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/pendingSpectators?contains=&approvedEmail=&limit=&triggeringEmail=&ticketId=&offset=®istered="
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: api_key
        ApiKeyAuth api_key = (ApiKeyAuth) defaultClient.getAuthentication("api_key");
        api_key.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //api_key.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | Set the number of results returned.
        String offset = offset_example; // String | Specify the offset of the first hit to return.
        String contains = contains_example; // String | 
        String approvedEmail = approvedEmail_example; // String | 
        String triggeringEmail = triggeringEmail_example; // String | 
        String ticketId = ticketId_example; // String | 
        String registered = registered_example; // String | 
        
        try {
            OrganizerPendingSpectatorsSearchResponse result = apiInstance.organizerPendingSpectatorsGet(limit, offset, contains, approvedEmail, triggeringEmail, ticketId, registered);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerPendingSpectatorsGet");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String limit = limit_example; // String | Set the number of results returned.
        String offset = offset_example; // String | Specify the offset of the first hit to return.
        String contains = contains_example; // String | 
        String approvedEmail = approvedEmail_example; // String | 
        String triggeringEmail = triggeringEmail_example; // String | 
        String ticketId = ticketId_example; // String | 
        String registered = registered_example; // String | 
        
        try {
            OrganizerPendingSpectatorsSearchResponse result = apiInstance.organizerPendingSpectatorsGet(limit, offset, contains, approvedEmail, triggeringEmail, ticketId, registered);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerPendingSpectatorsGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: api_key)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"x-api-key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"x-api-key"];


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *limit = limit_example; // Set the number of results returned. (default to null)
String *offset = offset_example; // Specify the offset of the first hit to return. (default to null)
String *contains = contains_example; //  (optional) (default to null)
String *approvedEmail = approvedEmail_example; //  (optional) (default to null)
String *triggeringEmail = triggeringEmail_example; //  (optional) (default to null)
String *ticketId = ticketId_example; //  (optional) (default to null)
String *registered = registered_example; //  (optional) (default to null)

[apiInstance organizerPendingSpectatorsGetWith:limit
    offset:offset
    contains:contains
    approvedEmail:approvedEmail
    triggeringEmail:triggeringEmail
    ticketId:ticketId
    registered:registered
              completionHandler: ^(OrganizerPendingSpectatorsSearchResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: api_key
var api_key = defaultClient.authentications['api_key'];
api_key.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//api_key.apiKeyPrefix['x-api-key'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var limit = limit_example; // {String} Set the number of results returned.
var offset = offset_example; // {String} Specify the offset of the first hit to return.
var opts = {
  'contains': contains_example, // {String} 
  'approvedEmail': approvedEmail_example, // {String} 
  'triggeringEmail': triggeringEmail_example, // {String} 
  'ticketId': ticketId_example, // {String} 
  'registered': registered_example // {String} 
};

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

namespace Example
{
    public class organizerPendingSpectatorsGetExample
    {
        public void main()
        {
            // Configure API key authorization: api_key
            Configuration.Default.ApiKey.Add("x-api-key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("x-api-key", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var limit = limit_example;  // String | Set the number of results returned. (default to null)
            var offset = offset_example;  // String | Specify the offset of the first hit to return. (default to null)
            var contains = contains_example;  // String |  (optional)  (default to null)
            var approvedEmail = approvedEmail_example;  // String |  (optional)  (default to null)
            var triggeringEmail = triggeringEmail_example;  // String |  (optional)  (default to null)
            var ticketId = ticketId_example;  // String |  (optional)  (default to null)
            var registered = registered_example;  // String |  (optional)  (default to null)

            try {
                OrganizerPendingSpectatorsSearchResponse result = apiInstance.organizerPendingSpectatorsGet(limit, offset, contains, approvedEmail, triggeringEmail, ticketId, registered);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPendingSpectatorsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: api_key
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('x-api-key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('x-api-key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$limit = limit_example; // String | Set the number of results returned.
$offset = offset_example; // String | Specify the offset of the first hit to return.
$contains = contains_example; // String | 
$approvedEmail = approvedEmail_example; // String | 
$triggeringEmail = triggeringEmail_example; // String | 
$ticketId = ticketId_example; // String | 
$registered = registered_example; // String | 

try {
    $result = $api_instance->organizerPendingSpectatorsGet($limit, $offset, $contains, $approvedEmail, $triggeringEmail, $ticketId, $registered);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->organizerPendingSpectatorsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Configure API key authorization: api_key
$WWW::OPenAPIClient::Configuration::api_key->{'x-api-key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'x-api-key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $limit = limit_example; # String | Set the number of results returned.
my $offset = offset_example; # String | Specify the offset of the first hit to return.
my $contains = contains_example; # String | 
my $approvedEmail = approvedEmail_example; # String | 
my $triggeringEmail = triggeringEmail_example; # String | 
my $ticketId = ticketId_example; # String | 
my $registered = registered_example; # String | 

eval { 
    my $result = $api_instance->organizerPendingSpectatorsGet(limit => $limit, offset => $offset, contains => $contains, approvedEmail => $approvedEmail, triggeringEmail => $triggeringEmail, ticketId => $ticketId, registered => $registered);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->organizerPendingSpectatorsGet: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: api_key
openapi_client.configuration.api_key['x-api-key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['x-api-key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
limit = limit_example # String | Set the number of results returned. (default to null)
offset = offset_example # String | Specify the offset of the first hit to return. (default to null)
contains = contains_example # String |  (optional) (default to null)
approvedEmail = approvedEmail_example # String |  (optional) (default to null)
triggeringEmail = triggeringEmail_example # String |  (optional) (default to null)
ticketId = ticketId_example # String |  (optional) (default to null)
registered = registered_example # String |  (optional) (default to null)

try: 
    api_response = api_instance.organizer_pending_spectators_get(limit, offset, contains=contains, approvedEmail=approvedEmail, triggeringEmail=triggeringEmail, ticketId=ticketId, registered=registered)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerPendingSpectatorsGet: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let limit = limit_example; // String
    let offset = offset_example; // String
    let contains = contains_example; // String
    let approvedEmail = approvedEmail_example; // String
    let triggeringEmail = triggeringEmail_example; // String
    let ticketId = ticketId_example; // String
    let registered = registered_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.organizerPendingSpectatorsGet(limit, offset, contains, approvedEmail, triggeringEmail, ticketId, registered, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
contains
String
approvedEmail
String
limit*
String
Set the number of results returned.
Required
triggeringEmail
String
ticketId
String
offset*
String
Specify the offset of the first hit to return.
Required
registered
String

Responses


organizerPost

[OPERATOR] Create an inactive organizer.


/organizer

Usage and SDK Samples

curl -X POST\
-H "Authorization: [[apiKey]]"\
 -H "Accept: application/json"\
 -H "Content-Type: application/json"\
 "https://api.tixngo.io/v3/organizer"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

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

public class DefaultApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure API key authorization: tyxr-organizers
        ApiKeyAuth tyxr-organizers = (ApiKeyAuth) defaultClient.getAuthentication("tyxr-organizers");
        tyxr-organizers.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //tyxr-organizers.setApiKeyPrefix("Token");
        
        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        OrganizerProfile organizerProfile = ; // OrganizerProfile | 
        
        try {
            OrganizerPostResponse result = apiInstance.organizerPost(organizerProfile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerPost");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        OrganizerProfile organizerProfile = ; // OrganizerProfile | 
        
        try {
            OrganizerPostResponse result = apiInstance.organizerPost(organizerProfile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#organizerPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: tyxr-organizers)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"Authorization"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"Authorization"];


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

[apiInstance organizerPostWith:organizerProfile
              completionHandler: ^(OrganizerPostResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var TixngoRestApi = require('tixngo_rest_api');
var defaultClient = TixngoRestApi.ApiClient.instance;

// Configure API key authorization: tyxr-organizers
var tyxr-organizers = defaultClient.authentications['tyxr-organizers'];
tyxr-organizers.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//tyxr-organizers.apiKeyPrefix['Authorization'] = "Token";

// Create an instance of the API class
var api = new TixngoRestApi.DefaultApi()
var organizerProfile = ; // {OrganizerProfile} 

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

namespace Example
{
    public class organizerPostExample
    {
        public void main()
        {
            // Configure API key authorization: tyxr-organizers
            Configuration.Default.ApiKey.Add("Authorization", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("Authorization", "Bearer");
            
            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var organizerProfile = new OrganizerProfile(); // OrganizerProfile | 

            try {
                OrganizerPostResponse result = apiInstance.organizerPost(organizerProfile);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.organizerPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: tyxr-organizers
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('Authorization', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('Authorization', 'Bearer');

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

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

# Configure API key authorization: tyxr-organizers
$WWW::OPenAPIClient::Configuration::api_key->{'Authorization'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'Authorization'} = "Bearer";

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

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

# Configure API key authorization: tyxr-organizers
openapi_client.configuration.api_key['Authorization'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['Authorization'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
organizerProfile =  # OrganizerProfile | 

try: 
    api_response = api_instance.organizer_post(organizerProfile)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->organizerPost: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let organizerProfile = ; // OrganizerProfile

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

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

Scopes

Parameters

Body parameters
Name Description
organizerProfile *

Responses


organizerProfileGet

Get the profile of the caller (organizer)


/organizer/profile

Usage and SDK Samples

curl -X GET\
-H "x-api-key: [[apiKey]]"\
 -H "Accept: application/json"\
 "https://api.tixngo.io/v3/organizer/profile"