Unified SAFIS API - Production

API and SDK Documentation

Version: 2.0.0

Overview

This API is used by remote applications to communicate with the SAFIS backend database server. It is not intended for any other purpose. This document is intended as a programmer’s reference manual. It is used by both application developers who build a front-end, and the programmers who maintain this API back-end.

To request an API key, please contact support@accsp.org

Server and base url: https://safis.accsp.org/safis_prod/safis_prod/api/

EDR

lookupListDateChangedPost

lookup_list_date_changed

fetch the last date that the specified lookup table(s) were changed.

/lookup_list_date_changed

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/lookup_list_date_changed"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Non-Confidential
        HttpBasicAuth Non-Confidential = (HttpBasicAuth) defaultClient.getAuthentication("Non-Confidential");
        Non-Confidential.setUsername("YOUR USERNAME");
        Non-Confidential.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        Lookup_list_date_changed_request body = ; // Lookup_list_date_changed_request | 
        try {
            lookup_list_date_changed_response result = apiInstance.lookupListDateChangedPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#lookupListDateChangedPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        Lookup_list_date_changed_request body = ; // Lookup_list_date_changed_request | 
        try {
            lookup_list_date_changed_response result = apiInstance.lookupListDateChangedPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#lookupListDateChangedPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Non-Confidential)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Lookup_list_date_changed_request *body = ; // 

EDRApi *apiInstance = [[EDRApi alloc] init];

// lookup_list_date_changed
[apiInstance lookupListDateChangedPostWith:body
              completionHandler: ^(lookup_list_date_changed_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Non-Confidential
var Non-Confidential = defaultClient.authentications['Non-Confidential'];
Non-Confidential.username = 'YOUR USERNAME'
Non-Confidential.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var body = ; // {{Lookup_list_date_changed_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class lookupListDateChangedPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Non-Confidential
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new Lookup_list_date_changed_request(); // Lookup_list_date_changed_request | 

            try
            {
                // lookup_list_date_changed
                lookup_list_date_changed_response result = apiInstance.lookupListDateChangedPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.lookupListDateChangedPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Non-Confidential
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = ; // Lookup_list_date_changed_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Non-Confidential
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::Lookup_list_date_changed_request->new(); # Lookup_list_date_changed_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Non-Confidential
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body =  # Lookup_list_date_changed_request | 

try: 
    # lookup_list_date_changed
    api_response = api_instance.lookup_list_date_changed_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->lookupListDateChangedPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

lookupListPost

lookup_list

fetch a set of rows for a specified lookup table. All lists accept the p_partner parameter and are partner specific with the exception of VESSELS, PORTS, USER_NOTIFICATIONS, VMS_LANDING_LOCATIONS, SCIFISH_SPECIES AND SCIFISH_TRIP_ACTIVITY,TRIP_PROCESSED,HMS_TARGET_SPECIES,HMS_GEARS,PARTNER_MANAGED_FOOTER. All vessels returned are federally permitted vessels.

/lookup_list

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/lookup_list"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Non-Confidential
        HttpBasicAuth Non-Confidential = (HttpBasicAuth) defaultClient.getAuthentication("Non-Confidential");
        Non-Confidential.setUsername("YOUR USERNAME");
        Non-Confidential.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        Lookup_list_request body = ; // Lookup_list_request | 
        try {
            lookup_list_responses result = apiInstance.lookupListPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#lookupListPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        Lookup_list_request body = ; // Lookup_list_request | 
        try {
            lookup_list_responses result = apiInstance.lookupListPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#lookupListPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Non-Confidential)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Lookup_list_request *body = ; // 

EDRApi *apiInstance = [[EDRApi alloc] init];

// lookup_list
[apiInstance lookupListPostWith:body
              completionHandler: ^(lookup_list_responses output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Non-Confidential
var Non-Confidential = defaultClient.authentications['Non-Confidential'];
Non-Confidential.username = 'YOUR USERNAME'
Non-Confidential.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var body = ; // {{Lookup_list_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class lookupListPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Non-Confidential
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new Lookup_list_request(); // Lookup_list_request | 

            try
            {
                // lookup_list
                lookup_list_responses result = apiInstance.lookupListPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.lookupListPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Non-Confidential
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = ; // Lookup_list_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Non-Confidential
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::Lookup_list_request->new(); # Lookup_list_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Non-Confidential
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body =  # Lookup_list_request | 

try: 
    # lookup_list
    api_response = api_instance.lookup_list_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->lookupListPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - Successful Response

Schema

negReportsUploadErrorsPost

neg_reports_upload_errors

Fetch a list of errors from a neg_reports_upload attempt that did not load.

/neg_reports_upload_errors

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/neg_reports_upload_errors"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        Event_id body = ; // Event_id | 
        try {
            neg_dealer_reports_error_response result = apiInstance.negReportsUploadErrorsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#negReportsUploadErrorsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        Event_id body = ; // Event_id | 
        try {
            neg_dealer_reports_error_response result = apiInstance.negReportsUploadErrorsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#negReportsUploadErrorsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Event_id *body = ; // 

EDRApi *apiInstance = [[EDRApi alloc] init];

// neg_reports_upload_errors 
[apiInstance negReportsUploadErrorsPostWith:body
              completionHandler: ^(neg_dealer_reports_error_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var body = ; // {{Event_id}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class negReportsUploadErrorsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new Event_id(); // Event_id | 

            try
            {
                // neg_reports_upload_errors 
                neg_dealer_reports_error_response result = apiInstance.negReportsUploadErrorsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.negReportsUploadErrorsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = ; // Event_id | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::Event_id->new(); # Event_id | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body =  # Event_id | 

try: 
    # neg_reports_upload_errors 
    api_response = api_instance.neg_reports_upload_errors_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->negReportsUploadErrorsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

negReportsUploadPost

neg_reports_upload

Send a set of negative dealer reports to safis. They can be sent as single records (with no end date). Or as a range (including an end date)

/neg_reports_upload

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/neg_reports_upload"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        Neg_dealer_reports body = ; // Neg_dealer_reports | 
        try {
            neg_dealer_reports_response result = apiInstance.negReportsUploadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#negReportsUploadPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        Neg_dealer_reports body = ; // Neg_dealer_reports | 
        try {
            neg_dealer_reports_response result = apiInstance.negReportsUploadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#negReportsUploadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Neg_dealer_reports *body = ; // 

EDRApi *apiInstance = [[EDRApi alloc] init];

// neg_reports_upload 
[apiInstance negReportsUploadPostWith:body
              completionHandler: ^(neg_dealer_reports_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var body = ; // {{Neg_dealer_reports}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class negReportsUploadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new Neg_dealer_reports(); // Neg_dealer_reports | 

            try
            {
                // neg_reports_upload 
                neg_dealer_reports_response result = apiInstance.negReportsUploadPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.negReportsUploadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = ; // Neg_dealer_reports | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::Neg_dealer_reports->new(); # Neg_dealer_reports | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body =  # Neg_dealer_reports | 

try: 
    # neg_reports_upload 
    api_response = api_instance.neg_reports_upload_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->negReportsUploadPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

permitCompliancePost

permit_compliance

checks the current compliance status of a dealer permit

/permit_compliance

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/permit_compliance"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        Permit_compliance_request body = ; // Permit_compliance_request | 
        try {
            permit_compliance_response result = apiInstance.permitCompliancePost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#permitCompliancePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        Permit_compliance_request body = ; // Permit_compliance_request | 
        try {
            permit_compliance_response result = apiInstance.permitCompliancePost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#permitCompliancePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Permit_compliance_request *body = ; //  (optional)

EDRApi *apiInstance = [[EDRApi alloc] init];

// permit_compliance 
[apiInstance permitCompliancePostWith:body
              completionHandler: ^(permit_compliance_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var opts = { 
  'body':  // {{Permit_compliance_request}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.permitCompliancePost(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class permitCompliancePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new Permit_compliance_request(); // Permit_compliance_request |  (optional) 

            try
            {
                // permit_compliance 
                permit_compliance_response result = apiInstance.permitCompliancePost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.permitCompliancePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = ; // Permit_compliance_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::Permit_compliance_request->new(); # Permit_compliance_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body =  # Permit_compliance_request |  (optional)

try: 
    # permit_compliance 
    api_response = api_instance.permit_compliance_post(body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->permitCompliancePost: %s\n" % e)

Parameters

Body parameters

Name	Description
body

Responses

Status: 200 - output of the endpoint

Schema

permitEndorsementsPost

permit_endorsements

fetch a list of endorsements for a given a partner

/permit_endorsements

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/permit_endorsements"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        Permit_endorsements_request body = ; // Permit_endorsements_request | 
        try {
            permit_endorsements_responses result = apiInstance.permitEndorsementsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#permitEndorsementsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        Permit_endorsements_request body = ; // Permit_endorsements_request | 
        try {
            permit_endorsements_responses result = apiInstance.permitEndorsementsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#permitEndorsementsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Permit_endorsements_request *body = ; // 

EDRApi *apiInstance = [[EDRApi alloc] init];

// permit_endorsements 
[apiInstance permitEndorsementsPostWith:body
              completionHandler: ^(permit_endorsements_responses output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var body = ; // {{Permit_endorsements_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class permitEndorsementsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new Permit_endorsements_request(); // Permit_endorsements_request | 

            try
            {
                // permit_endorsements 
                permit_endorsements_responses result = apiInstance.permitEndorsementsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.permitEndorsementsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = ; // Permit_endorsements_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::Permit_endorsements_request->new(); # Permit_endorsements_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body =  # Permit_endorsements_request | 

try: 
    # permit_endorsements 
    api_response = api_instance.permit_endorsements_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->permitEndorsementsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

reportsUploadErrorsPost

reports_upload_errors

Fetch a list of errors from a dealer reports_upload attempt that did not load.

/reports_upload_errors

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/reports_upload_errors"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        Event_id body = ; // Event_id | 
        try {
            dealer_reports_error_response result = apiInstance.reportsUploadErrorsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#reportsUploadErrorsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        Event_id body = ; // Event_id | 
        try {
            dealer_reports_error_response result = apiInstance.reportsUploadErrorsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#reportsUploadErrorsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Event_id *body = ; // 

EDRApi *apiInstance = [[EDRApi alloc] init];

// reports_upload_errors 
[apiInstance reportsUploadErrorsPostWith:body
              completionHandler: ^(dealer_reports_error_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var body = ; // {{Event_id}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class reportsUploadErrorsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new Event_id(); // Event_id | 

            try
            {
                // reports_upload_errors 
                dealer_reports_error_response result = apiInstance.reportsUploadErrorsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.reportsUploadErrorsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = ; // Event_id | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::Event_id->new(); # Event_id | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body =  # Event_id | 

try: 
    # reports_upload_errors 
    api_response = api_instance.reports_upload_errors_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->reportsUploadErrorsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

reportsUploadPost

reports_upload

Upload an array of dealer reports including associated landings

/reports_upload

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/reports_upload"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        Dealer_reports_upload_request body = ; // Dealer_reports_upload_request | 
        try {
            dealer_reports_response result = apiInstance.reportsUploadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#reportsUploadPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        Dealer_reports_upload_request body = ; // Dealer_reports_upload_request | 
        try {
            dealer_reports_response result = apiInstance.reportsUploadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#reportsUploadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Dealer_reports_upload_request *body = ; // 

EDRApi *apiInstance = [[EDRApi alloc] init];

// reports_upload 
[apiInstance reportsUploadPostWith:body
              completionHandler: ^(dealer_reports_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var body = ; // {{Dealer_reports_upload_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class reportsUploadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new Dealer_reports_upload_request(); // Dealer_reports_upload_request | 

            try
            {
                // reports_upload 
                dealer_reports_response result = apiInstance.reportsUploadPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.reportsUploadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = ; // Dealer_reports_upload_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::Dealer_reports_upload_request->new(); # Dealer_reports_upload_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body =  # Dealer_reports_upload_request | 

try: 
    # reports_upload 
    api_response = api_instance.reports_upload_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->reportsUploadPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

userPermitsPost

user_permits

This call retrieves a list of fisher or dealer permits for the logged in user with a valid username, password and API key.

/user_permits

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/user_permits"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EDRApi;

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

public class EDRApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        EDRApi apiInstance = new EDRApi();
        User_permits_request body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // User_permits_request | 
        try {
            user_permits_response result = apiInstance.userPermitsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#userPermitsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.EDRApi;

public class EDRApiExample {

    public static void main(String[] args) {
        EDRApi apiInstance = new EDRApi();
        User_permits_request body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // User_permits_request | 
        try {
            user_permits_response result = apiInstance.userPermitsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EDRApi#userPermitsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
User_permits_request *body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // 

EDRApi *apiInstance = [[EDRApi alloc] init];

// user_permits
[apiInstance userPermitsPostWith:body
              completionHandler: ^(user_permits_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.EDRApi()
var body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // {{User_permits_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class userPermitsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new EDRApi();
            var body = new User_permits_request(); // User_permits_request | 

            try
            {
                // user_permits
                user_permits_response result = apiInstance.userPermitsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EDRApi.userPermitsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiEDRApi();
$body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // User_permits_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EDRApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::EDRApi->new();
my $body = WWW::SwaggerClient::Object::User_permits_request->new(); # User_permits_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.EDRApi()
body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
} # User_permits_request | 

try: 
    # user_permits
    api_response = api_instance.user_permits_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EDRApi->userPermitsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful response

Schema

ETrips

lookupListByAttributePost

lookup_list_by_attribute

fetch a set of rows for specified attribute lookup list. Used in combination with _additional_attributes lookup_list

/lookup_list_by_attribute

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/lookup_list_by_attribute"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Non-Confidential
        HttpBasicAuth Non-Confidential = (HttpBasicAuth) defaultClient.getAuthentication("Non-Confidential");
        Non-Confidential.setUsername("YOUR USERNAME");
        Non-Confidential.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Lookup_list_attribute_request body = ; // Lookup_list_attribute_request | 
        try {
            lookup_list_attribute_response result = apiInstance.lookupListByAttributePost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#lookupListByAttributePost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Lookup_list_attribute_request body = ; // Lookup_list_attribute_request | 
        try {
            lookup_list_attribute_response result = apiInstance.lookupListByAttributePost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#lookupListByAttributePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Non-Confidential)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Lookup_list_attribute_request *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// lookup_list_by_attribute
[apiInstance lookupListByAttributePostWith:body
              completionHandler: ^(lookup_list_attribute_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Non-Confidential
var Non-Confidential = defaultClient.authentications['Non-Confidential'];
Non-Confidential.username = 'YOUR USERNAME'
Non-Confidential.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Lookup_list_attribute_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class lookupListByAttributePostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Non-Confidential
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Lookup_list_attribute_request(); // Lookup_list_attribute_request | 

            try
            {
                // lookup_list_by_attribute
                lookup_list_attribute_response result = apiInstance.lookupListByAttributePost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.lookupListByAttributePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Non-Confidential
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Lookup_list_attribute_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Non-Confidential
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Lookup_list_attribute_request->new(); # Lookup_list_attribute_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Non-Confidential
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Lookup_list_attribute_request | 

try: 
    # lookup_list_by_attribute
    api_response = api_instance.lookup_list_by_attribute_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->lookupListByAttributePost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

lookupListDateChangedPost

lookup_list_date_changed

fetch the last date that the specified lookup table(s) were changed.

/lookup_list_date_changed

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/lookup_list_date_changed"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Non-Confidential
        HttpBasicAuth Non-Confidential = (HttpBasicAuth) defaultClient.getAuthentication("Non-Confidential");
        Non-Confidential.setUsername("YOUR USERNAME");
        Non-Confidential.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Lookup_list_date_changed_request body = ; // Lookup_list_date_changed_request | 
        try {
            lookup_list_date_changed_response result = apiInstance.lookupListDateChangedPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#lookupListDateChangedPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Lookup_list_date_changed_request body = ; // Lookup_list_date_changed_request | 
        try {
            lookup_list_date_changed_response result = apiInstance.lookupListDateChangedPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#lookupListDateChangedPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Non-Confidential)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Lookup_list_date_changed_request *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// lookup_list_date_changed
[apiInstance lookupListDateChangedPostWith:body
              completionHandler: ^(lookup_list_date_changed_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Non-Confidential
var Non-Confidential = defaultClient.authentications['Non-Confidential'];
Non-Confidential.username = 'YOUR USERNAME'
Non-Confidential.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Lookup_list_date_changed_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class lookupListDateChangedPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Non-Confidential
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Lookup_list_date_changed_request(); // Lookup_list_date_changed_request | 

            try
            {
                // lookup_list_date_changed
                lookup_list_date_changed_response result = apiInstance.lookupListDateChangedPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.lookupListDateChangedPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Non-Confidential
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Lookup_list_date_changed_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Non-Confidential
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Lookup_list_date_changed_request->new(); # Lookup_list_date_changed_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Non-Confidential
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Lookup_list_date_changed_request | 

try: 
    # lookup_list_date_changed
    api_response = api_instance.lookup_list_date_changed_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->lookupListDateChangedPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

lookupListPost

lookup_list

/lookup_list

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/lookup_list"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Non-Confidential
        HttpBasicAuth Non-Confidential = (HttpBasicAuth) defaultClient.getAuthentication("Non-Confidential");
        Non-Confidential.setUsername("YOUR USERNAME");
        Non-Confidential.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Lookup_list_request body = ; // Lookup_list_request | 
        try {
            lookup_list_responses result = apiInstance.lookupListPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#lookupListPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Lookup_list_request body = ; // Lookup_list_request | 
        try {
            lookup_list_responses result = apiInstance.lookupListPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#lookupListPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Non-Confidential)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Lookup_list_request *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// lookup_list
[apiInstance lookupListPostWith:body
              completionHandler: ^(lookup_list_responses output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Non-Confidential
var Non-Confidential = defaultClient.authentications['Non-Confidential'];
Non-Confidential.username = 'YOUR USERNAME'
Non-Confidential.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Lookup_list_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class lookupListPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Non-Confidential
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Lookup_list_request(); // Lookup_list_request | 

            try
            {
                // lookup_list
                lookup_list_responses result = apiInstance.lookupListPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.lookupListPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Non-Confidential
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Lookup_list_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Non-Confidential
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Lookup_list_request->new(); # Lookup_list_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Non-Confidential
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Lookup_list_request | 

try: 
    # lookup_list
    api_response = api_instance.lookup_list_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->lookupListPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - Successful Response

Schema

negTripsNotProcessedPost

neg_trips_not_processed

This endpoint provides a list of negative (did not fish) trips submitted under the provided license (p_license_nbr) which either 1) did not fully process after being received by the ACCSP or 2) processed successfully but were subsequently deleted by a partner administrator.

/neg_trips_not_processed

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/neg_trips_not_processed"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        
        ETripsApi apiInstance = new ETripsApi();
        Neg_trips_download_request body = ; // Neg_trips_download_request | 
        try {
            neg_trips_download_response result = apiInstance.negTripsNotProcessedPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#negTripsNotProcessedPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Neg_trips_download_request body = ; // Neg_trips_download_request | 
        try {
            neg_trips_download_response result = apiInstance.negTripsNotProcessedPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#negTripsNotProcessedPost");
            e.printStackTrace();
        }
    }
}

Neg_trips_download_request *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// neg_trips_not_processed
[apiInstance negTripsNotProcessedPostWith:body
              completionHandler: ^(neg_trips_download_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Neg_trips_download_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ETripsApi();
            var body = new Neg_trips_download_request(); // Neg_trips_download_request | 

            try
            {
                // neg_trips_not_processed
                neg_trips_download_response result = apiInstance.negTripsNotProcessedPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.negTripsNotProcessedPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Neg_trips_download_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Neg_trips_download_request->new(); # Neg_trips_download_request | 

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

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

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Neg_trips_download_request | 

try: 
    # neg_trips_not_processed
    api_response = api_instance.neg_trips_not_processed_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->negTripsNotProcessedPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

negTripsUploadErrorsPost

neg_trips_upload_errors

fetch a list of errors from negative/did not fish reports that didn’t load after calling neg_trips_upload.

/neg_trips_upload_errors

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/neg_trips_upload_errors"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Event_id body = ; // Event_id | 
        try {
            neg_trips_error_response result = apiInstance.negTripsUploadErrorsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#negTripsUploadErrorsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Event_id body = ; // Event_id | 
        try {
            neg_trips_error_response result = apiInstance.negTripsUploadErrorsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#negTripsUploadErrorsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Event_id *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// neg_trips_upload_errors 
[apiInstance negTripsUploadErrorsPostWith:body
              completionHandler: ^(neg_trips_error_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Event_id}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class negTripsUploadErrorsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Event_id(); // Event_id | 

            try
            {
                // neg_trips_upload_errors 
                neg_trips_error_response result = apiInstance.negTripsUploadErrorsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.negTripsUploadErrorsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Event_id | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Event_id->new(); # Event_id | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Event_id | 

try: 
    # neg_trips_upload_errors 
    api_response = api_instance.neg_trips_upload_errors_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->negTripsUploadErrorsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

negTripsUploadPost

neg_trips_upload

The neg_trips_upload endpoint accepts multiple reports within a single API call (see example request). However, to avoid unexpected validation failures we recommend sending reports from the same fishing license, participant and vessel within individual API calls. Including different fishing licenses or vessels within a single API call may result in unexpected validation failures and misleading errors. the sector payload is a required value for SERO partners.

/neg_trips_upload

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/neg_trips_upload"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Neg_trips body = ; // Neg_trips | 
        try {
            neg_trips_response result = apiInstance.negTripsUploadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#negTripsUploadPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Neg_trips body = ; // Neg_trips | 
        try {
            neg_trips_response result = apiInstance.negTripsUploadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#negTripsUploadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Neg_trips *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// neg_trips_upload 
[apiInstance negTripsUploadPostWith:body
              completionHandler: ^(neg_trips_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Neg_trips}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class negTripsUploadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Neg_trips(); // Neg_trips | 

            try
            {
                // neg_trips_upload 
                neg_trips_response result = apiInstance.negTripsUploadPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.negTripsUploadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Neg_trips | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Neg_trips->new(); # Neg_trips | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Neg_trips | 

try: 
    # neg_trips_upload 
    api_response = api_instance.neg_trips_upload_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->negTripsUploadPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - A HTTP status code 200/OK refers to the status of the HTTP request and does not indicate whether or not ACCSP data validations were successful. Data validation errors are generated during record processing and are returned as “errors” in the response.

Schema

notificationUploadPost

notification_upload

The calling app sends a notification record in JSON format. The record consists of core notification details submitted as parameter values, and optional partner-managed notification attributes submitted as a JSON array. See example request. The response, also in JSON format, includes the universal trip ID for the trip. The universal trip ID is created when a notification record is submitted if this is the first notification associated with the trip. If an existing universal trip ID already exists for the same trip, the previously generated universal trip ID is returned.

/notification_upload

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/notification_upload"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Notification_upload_request body = ; // Notification_upload_request | 
        try {
            notification_upload_response result = apiInstance.notificationUploadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#notificationUploadPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Notification_upload_request body = ; // Notification_upload_request | 
        try {
            notification_upload_response result = apiInstance.notificationUploadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#notificationUploadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Notification_upload_request *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// notification_upload
[apiInstance notificationUploadPostWith:body
              completionHandler: ^(notification_upload_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Notification_upload_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class notificationUploadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Notification_upload_request(); // Notification_upload_request | 

            try
            {
                // notification_upload
                notification_upload_response result = apiInstance.notificationUploadPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.notificationUploadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Notification_upload_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Notification_upload_request->new(); # Notification_upload_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Notification_upload_request | 

try: 
    # notification_upload
    api_response = api_instance.notification_upload_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->notificationUploadPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - A HTTP status code 200/OK refers to the status of the HTTP request and does not indicate whether or not ACCSP data validations were successful. Data validation errors are generated during record processing and are returned as “errors” in the response.

Schema

participantsPost

participants

Check for/update users with the given information. This call retrieves a list of participants in the SAFIS system with the supplier user identifiable information.

/participants

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/participants"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Participants body = ; // Participants | 
        try {
            participants_response result = apiInstance.participantsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#participantsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Participants body = ; // Participants | 
        try {
            participants_response result = apiInstance.participantsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#participantsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Participants *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// participants 
[apiInstance participantsPostWith:body
              completionHandler: ^(participants_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Participants}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class participantsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Participants(); // Participants | 

            try
            {
                // participants 
                participants_response result = apiInstance.participantsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.participantsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Participants | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Participants->new(); # Participants | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Participants | 

try: 
    # participants 
    api_response = api_instance.participants_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->participantsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

tripLocationsPost

trip_locations

This endpoint is used to send a set of trip locations to SAFIS. Records in the locations array should include a timestamp in UTC format. The ACCSP API expects a 'Z' or Zulu offset (e.g. 2021-11-26T18:31:30Z) and timestamps submitted without a time offset will be interpreted as not having one. Location records should also include latitude and longitude (5-decimal precision) within the range 20 to 50 and -100 to -60, respectively. See Request Sample. A vessel coast number or state registration number is required, if both values are sent the coast guard number will be used to validate the vessel.

/trip_locations

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/trip_locations"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Locations body = ; // Locations | 
        try {
            trip_locations_response result = apiInstance.tripLocationsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#tripLocationsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Locations body = ; // Locations | 
        try {
            trip_locations_response result = apiInstance.tripLocationsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#tripLocationsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Locations *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// trip_locations
[apiInstance tripLocationsPostWith:body
              completionHandler: ^(trip_locations_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Locations}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class tripLocationsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Locations(); // Locations | 

            try
            {
                // trip_locations
                trip_locations_response result = apiInstance.tripLocationsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.tripLocationsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Locations | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Locations->new(); # Locations | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Locations | 

try: 
    # trip_locations
    api_response = api_instance.trip_locations_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->tripLocationsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - A HTTP status code 200/OK refers to the status of the HTTP request and does not indicate whether or not ACCSP data validations were successful. Data validation errors are generated during record processing and are returned as “errors” in the response.

Schema

tripsDownloadPost

trips_download

retrieve set of trips rows from safis. A list of trips is requested from the SAFIS system within the upper and lower limits of the start and end dates (inclusive) . This list will only contain successfully uploaded trips and will be sent to same format as the trips_upload call.

/trips_download

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/trips_download"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        
        ETripsApi apiInstance = new ETripsApi();
        Trips_download_request body = ; // Trips_download_request | 
        try {
            trips_download_response result = apiInstance.tripsDownloadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#tripsDownloadPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Trips_download_request body = ; // Trips_download_request | 
        try {
            trips_download_response result = apiInstance.tripsDownloadPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#tripsDownloadPost");
            e.printStackTrace();
        }
    }
}

Trips_download_request *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// trips_download
[apiInstance tripsDownloadPostWith:body
              completionHandler: ^(trips_download_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Trips_download_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ETripsApi();
            var body = new Trips_download_request(); // Trips_download_request | 

            try
            {
                // trips_download
                trips_download_response result = apiInstance.tripsDownloadPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.tripsDownloadPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Trips_download_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Trips_download_request->new(); # Trips_download_request | 

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

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

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Trips_download_request | 

try: 
    # trips_download
    api_response = api_instance.trips_download_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->tripsDownloadPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

tripsUploadErrorsPost

trips_upload_errors

fetch a list of errors from trip rows that did not load. Should be called after trips_upload call if one or moreerrored records are indicated

/trips_upload_errors

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/trips_upload_errors"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Event_id body = ; // Event_id | 
        try {
            trip_upload_error_response result = apiInstance.tripsUploadErrorsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#tripsUploadErrorsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Event_id body = ; // Event_id | 
        try {
            trip_upload_error_response result = apiInstance.tripsUploadErrorsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#tripsUploadErrorsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Event_id *body = ; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// trips_upload_errors
[apiInstance tripsUploadErrorsPostWith:body
              completionHandler: ^(trip_upload_error_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Event_id}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class tripsUploadErrorsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Event_id(); // Event_id | 

            try
            {
                // trips_upload_errors
                trip_upload_error_response result = apiInstance.tripsUploadErrorsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.tripsUploadErrorsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Event_id | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Event_id->new(); # Event_id | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Event_id | 

try: 
    # trips_upload_errors
    api_response = api_instance.trips_upload_errors_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->tripsUploadErrorsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - output of the endpoint

Schema

tripsUploadPost

trips_upload

send a set of trips rows to safis using the request showen a trip submission that include three gear attributes. Resubmissions of trips previously submitted and processed successfully should include the accsp_trip_id (provided in response for successful submissions) and a trip_update flag (set value to Y). See example request.

/trips_upload

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/trips_upload"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        Trips body = ; // Trips | 
        String appVersion = appVersion_example; // String | 
        String platform = platform_example; // String | 
        String appName = appName_example; // String | 
        try {
            trip_upload_response result = apiInstance.tripsUploadPost(body, appVersion, platform, appName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#tripsUploadPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        Trips body = ; // Trips | 
        String appVersion = appVersion_example; // String | 
        String platform = platform_example; // String | 
        String appName = appName_example; // String | 
        try {
            trip_upload_response result = apiInstance.tripsUploadPost(body, appVersion, platform, appName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#tripsUploadPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Trips *body = ; // 
String *appVersion = appVersion_example; // 
String *platform = platform_example; //  (optional)
String *appName = appName_example; //  (optional)

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// trips_upload 
[apiInstance tripsUploadPostWith:body
    appVersion:appVersion
    platform:platform
    appName:appName
              completionHandler: ^(trip_upload_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = ; // {{Trips}} 
var appVersion = appVersion_example; // {{String}} 
var opts = { 
  'platform': platform_example // {{String}} 
  'appName': appName_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.tripsUploadPost(bodyappVersion, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class tripsUploadPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new Trips(); // Trips | 
            var appVersion = appVersion_example;  // String | 
            var platform = platform_example;  // String |  (optional) 
            var appName = appName_example;  // String |  (optional) 

            try
            {
                // trips_upload 
                trip_upload_response result = apiInstance.tripsUploadPost(body, appVersion, platform, appName);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.tripsUploadPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = ; // Trips | 
$appVersion = appVersion_example; // String | 
$platform = platform_example; // String | 
$appName = appName_example; // String | 

try {
    $result = $api_instance->tripsUploadPost($body, $appVersion, $platform, $appName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ETripsApi->tripsUploadPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::Trips->new(); # Trips | 
my $appVersion = appVersion_example; # String | 
my $platform = platform_example; # String | 
my $appName = appName_example; # String | 

eval { 
    my $result = $api_instance->tripsUploadPost(body => $body, appVersion => $appVersion, platform => $platform, appName => $appName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ETripsApi->tripsUploadPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body =  # Trips | 
appVersion = appVersion_example # String | 
platform = platform_example # String |  (optional)
appName = appName_example # String |  (optional)

try: 
    # trips_upload 
    api_response = api_instance.trips_upload_post(body, appVersion, platform=platform, appName=appName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->tripsUploadPost: %s\n" % e)

Parameters

Header parameters

Name	Description
AppVersion*	String Required
Platform	String
AppName	String

Body parameters

Name	Description
body *

Responses

Status: 200 - A HTTP status code 200/OK refers to the status of the HTTP request and does not indicate whether or not ACCSP data validations were successful. Data validation errors are generated during record processing and are returned as “errors” in the response.

Schema

userPermitsPost

user_permits

This call retrieves a list of fisher or dealer permits for the logged in user with a valid username, password and API key.

/user_permits

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://safis.accsp.org/safis_prod/safis_prod/api/user_permits"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ETripsApi;

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

public class ETripsApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        // Configure HTTP basic authorization: Confidential-API
        HttpBasicAuth Confidential-API = (HttpBasicAuth) defaultClient.getAuthentication("Confidential-API");
        Confidential-API.setUsername("YOUR USERNAME");
        Confidential-API.setPassword("YOUR PASSWORD");

        ETripsApi apiInstance = new ETripsApi();
        User_permits_request body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // User_permits_request | 
        try {
            user_permits_response result = apiInstance.userPermitsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#userPermitsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ETripsApi;

public class ETripsApiExample {

    public static void main(String[] args) {
        ETripsApi apiInstance = new ETripsApi();
        User_permits_request body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // User_permits_request | 
        try {
            user_permits_response result = apiInstance.userPermitsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ETripsApi#userPermitsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Confidential-API)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
User_permits_request *body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // 

ETripsApi *apiInstance = [[ETripsApi alloc] init];

// user_permits
[apiInstance userPermitsPostWith:body
              completionHandler: ^(user_permits_response output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var UnifiedSafisApiTest = require('unified_safis_api__test');
var defaultClient = UnifiedSafisApiTest.ApiClient.instance;
// Configure HTTP basic authorization: Confidential-API
var Confidential-API = defaultClient.authentications['Confidential-API'];
Confidential-API.username = 'YOUR USERNAME'
Confidential-API.password = 'YOUR PASSWORD'

var api = new UnifiedSafisApiTest.ETripsApi()
var body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // {{User_permits_request}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class userPermitsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: Confidential-API
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ETripsApi();
            var body = new User_permits_request(); // User_permits_request | 

            try
            {
                // user_permits
                user_permits_response result = apiInstance.userPermitsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ETripsApi.userPermitsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: Confidential-API
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiETripsApi();
$body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
}; // User_permits_request | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ETripsApi;
# Configure HTTP basic authorization: Confidential-API
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ETripsApi->new();
my $body = WWW::SwaggerClient::Object::User_permits_request->new(); # User_permits_request | 

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: Confidential-API
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ETripsApi()
body = {
  "value" : {
    "p_usertype" : "FISHER"
  }
} # User_permits_request | 

try: 
    # user_permits
    api_response = api_instance.user_permits_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ETripsApi->userPermitsPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - successful response

Schema