Astrow Cloud REST API

DailyOperation

putDailyAbsence

Puts absence for employee.


/dailyabsence

Usage and SDK Samples

curl -X PUT -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/dailyabsence"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DailyOperationApi;

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

public class DailyOperationApiExample {

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

        DailyOperationApi apiInstance = new DailyOperationApi();
        array[Absence] body = ; // array[Absence] | 
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        String includeNonWorkingDays = includeNonWorkingDays_example; // String | Whether  to add absence in non working days
        String dBLanguageField = dBLanguageField_example; // String | Astrow DB Language Field
        try {
            apiInstance.putDailyAbsence(body, employeeKeyName, includeNonWorkingDays, dBLanguageField);
        } catch (ApiException e) {
            System.err.println("Exception when calling DailyOperationApi#putDailyAbsence");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DailyOperationApi;

public class DailyOperationApiExample {

    public static void main(String[] args) {
        DailyOperationApi apiInstance = new DailyOperationApi();
        array[Absence] body = ; // array[Absence] | 
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        String includeNonWorkingDays = includeNonWorkingDays_example; // String | Whether  to add absence in non working days
        String dBLanguageField = dBLanguageField_example; // String | Astrow DB Language Field
        try {
            apiInstance.putDailyAbsence(body, employeeKeyName, includeNonWorkingDays, dBLanguageField);
        } catch (ApiException e) {
            System.err.println("Exception when calling DailyOperationApi#putDailyAbsence");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
array[Absence] *body = ; // 
String *employeeKeyName = employeeKeyName_example; // One of persnr, badgenr, employeenr, registernr
String *includeNonWorkingDays = includeNonWorkingDays_example; // Whether  to add absence in non working days
String *dBLanguageField = dBLanguageField_example; // Astrow DB Language Field

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

// Puts absence for employee.
[apiInstance putDailyAbsenceWith:body
    employeeKeyName:employeeKeyName
    includeNonWorkingDays:includeNonWorkingDays
    dBLanguageField:dBLanguageField
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.DailyOperationApi()
var body = ; // {{array[Absence]}} 
var employeeKeyName = employeeKeyName_example; // {{String}} One of persnr, badgenr, employeenr, registernr
var includeNonWorkingDays = includeNonWorkingDays_example; // {{String}} Whether  to add absence in non working days
var dBLanguageField = dBLanguageField_example; // {{String}} Astrow DB Language Field

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.putDailyAbsence(bodyemployeeKeyNameincludeNonWorkingDaysdBLanguageField, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DailyOperationApi();
            var body = new array[Absence](); // array[Absence] | 
            var employeeKeyName = employeeKeyName_example;  // String | One of persnr, badgenr, employeenr, registernr
            var includeNonWorkingDays = includeNonWorkingDays_example;  // String | Whether  to add absence in non working days
            var dBLanguageField = dBLanguageField_example;  // String | Astrow DB Language Field

            try
            {
                // Puts absence for employee.
                apiInstance.putDailyAbsence(body, employeeKeyName, includeNonWorkingDays, dBLanguageField);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DailyOperationApi.putDailyAbsence: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiDailyOperationApi();
$body = ; // array[Absence] | 
$employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
$includeNonWorkingDays = includeNonWorkingDays_example; // String | Whether  to add absence in non working days
$dBLanguageField = dBLanguageField_example; // String | Astrow DB Language Field

try {
    $api_instance->putDailyAbsence($body, $employeeKeyName, $includeNonWorkingDays, $dBLanguageField);
} catch (Exception $e) {
    echo 'Exception when calling DailyOperationApi->putDailyAbsence: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DailyOperationApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DailyOperationApi->new();
my $body = [WWW::SwaggerClient::Object::array[Absence]->new()]; # array[Absence] | 
my $employeeKeyName = employeeKeyName_example; # String | One of persnr, badgenr, employeenr, registernr
my $includeNonWorkingDays = includeNonWorkingDays_example; # String | Whether  to add absence in non working days
my $dBLanguageField = dBLanguageField_example; # String | Astrow DB Language Field

eval { 
    $api_instance->putDailyAbsence(body => $body, employeeKeyName => $employeeKeyName, includeNonWorkingDays => $includeNonWorkingDays, dBLanguageField => $dBLanguageField);
};
if ($@) {
    warn "Exception when calling DailyOperationApi->putDailyAbsence: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DailyOperationApi()
body =  # array[Absence] | 
employeeKeyName = employeeKeyName_example # String | One of persnr, badgenr, employeenr, registernr
includeNonWorkingDays = includeNonWorkingDays_example # String | Whether  to add absence in non working days
dBLanguageField = dBLanguageField_example # String | Astrow DB Language Field

try: 
    # Puts absence for employee.
    api_instance.put_daily_absence(body, employeeKeyName, includeNonWorkingDays, dBLanguageField)
except ApiException as e:
    print("Exception when calling DailyOperationApi->putDailyAbsence: %s\n" % e)

Parameters

Header parameters
Name Description
employeeKeyName*
String
One of persnr, badgenr, employeenr, registernr
Required
includeNonWorkingDays*
String
Whether to add absence in non working days
Required
DBLanguageField*
String
Astrow DB Language Field
Required
Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error • 9001 Invalid DB language field • 8000 Invalid employee key • 5002 Invalid date format

putDailyBooking

Puts booking for employee. File terminal License is needed


/dailybooking

Usage and SDK Samples

curl -X PUT -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/dailybooking"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DailyOperationApi;

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

public class DailyOperationApiExample {

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

        DailyOperationApi apiInstance = new DailyOperationApi();
        array[Booking] body = ; // array[Booking] | 
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        try {
            apiInstance.putDailyBooking(body, employeeKeyName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DailyOperationApi#putDailyBooking");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DailyOperationApi;

public class DailyOperationApiExample {

    public static void main(String[] args) {
        DailyOperationApi apiInstance = new DailyOperationApi();
        array[Booking] body = ; // array[Booking] | 
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        try {
            apiInstance.putDailyBooking(body, employeeKeyName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DailyOperationApi#putDailyBooking");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
array[Booking] *body = ; // 
String *employeeKeyName = employeeKeyName_example; // One of persnr, badgenr, employeenr, registernr

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

// Puts booking for employee. File terminal License is needed
[apiInstance putDailyBookingWith:body
    employeeKeyName:employeeKeyName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.DailyOperationApi()
var body = ; // {{array[Booking]}} 
var employeeKeyName = employeeKeyName_example; // {{String}} One of persnr, badgenr, employeenr, registernr

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.putDailyBooking(bodyemployeeKeyName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DailyOperationApi();
            var body = new array[Booking](); // array[Booking] | 
            var employeeKeyName = employeeKeyName_example;  // String | One of persnr, badgenr, employeenr, registernr

            try
            {
                // Puts booking for employee. File terminal License is needed
                apiInstance.putDailyBooking(body, employeeKeyName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DailyOperationApi.putDailyBooking: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiDailyOperationApi();
$body = ; // array[Booking] | 
$employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr

try {
    $api_instance->putDailyBooking($body, $employeeKeyName);
} catch (Exception $e) {
    echo 'Exception when calling DailyOperationApi->putDailyBooking: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DailyOperationApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DailyOperationApi->new();
my $body = [WWW::SwaggerClient::Object::array[Booking]->new()]; # array[Booking] | 
my $employeeKeyName = employeeKeyName_example; # String | One of persnr, badgenr, employeenr, registernr

eval { 
    $api_instance->putDailyBooking(body => $body, employeeKeyName => $employeeKeyName);
};
if ($@) {
    warn "Exception when calling DailyOperationApi->putDailyBooking: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DailyOperationApi()
body =  # array[Booking] | 
employeeKeyName = employeeKeyName_example # String | One of persnr, badgenr, employeenr, registernr

try: 
    # Puts booking for employee. File terminal License is needed
    api_instance.put_daily_booking(body, employeeKeyName)
except ApiException as e:
    print("Exception when calling DailyOperationApi->putDailyBooking: %s\n" % e)

Parameters

Header parameters
Name Description
employeeKeyName*
String
One of persnr, badgenr, employeenr, registernr
Required
Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error • 5001 No Astrow License to access this option • 5002 Invalid date format • 5003 No key passed • 5005 Employees not found • 5008 General error • 5000 Could not login in Astrow

putSchedule

Puts schedule for employee.Schedule import License is needed


/schedule

Usage and SDK Samples

curl -X PUT -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/schedule"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DailyOperationApi;

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

public class DailyOperationApiExample {

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

        DailyOperationApi apiInstance = new DailyOperationApi();
        array[Schedule] body = ; // array[Schedule] | 
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        try {
            apiInstance.putSchedule(body, employeeKeyName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DailyOperationApi#putSchedule");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DailyOperationApi;

public class DailyOperationApiExample {

    public static void main(String[] args) {
        DailyOperationApi apiInstance = new DailyOperationApi();
        array[Schedule] body = ; // array[Schedule] | 
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        try {
            apiInstance.putSchedule(body, employeeKeyName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DailyOperationApi#putSchedule");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
array[Schedule] *body = ; // 
String *employeeKeyName = employeeKeyName_example; // One of persnr, badgenr, employeenr, registernr

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

// Puts schedule for employee.Schedule import License is needed
[apiInstance putScheduleWith:body
    employeeKeyName:employeeKeyName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.DailyOperationApi()
var body = ; // {{array[Schedule]}} 
var employeeKeyName = employeeKeyName_example; // {{String}} One of persnr, badgenr, employeenr, registernr

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.putSchedule(bodyemployeeKeyName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DailyOperationApi();
            var body = new array[Schedule](); // array[Schedule] | 
            var employeeKeyName = employeeKeyName_example;  // String | One of persnr, badgenr, employeenr, registernr

            try
            {
                // Puts schedule for employee.Schedule import License is needed
                apiInstance.putSchedule(body, employeeKeyName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DailyOperationApi.putSchedule: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiDailyOperationApi();
$body = ; // array[Schedule] | 
$employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr

try {
    $api_instance->putSchedule($body, $employeeKeyName);
} catch (Exception $e) {
    echo 'Exception when calling DailyOperationApi->putSchedule: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DailyOperationApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DailyOperationApi->new();
my $body = [WWW::SwaggerClient::Object::array[Schedule]->new()]; # array[Schedule] | 
my $employeeKeyName = employeeKeyName_example; # String | One of persnr, badgenr, employeenr, registernr

eval { 
    $api_instance->putSchedule(body => $body, employeeKeyName => $employeeKeyName);
};
if ($@) {
    warn "Exception when calling DailyOperationApi->putSchedule: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DailyOperationApi()
body =  # array[Schedule] | 
employeeKeyName = employeeKeyName_example # String | One of persnr, badgenr, employeenr, registernr

try: 
    # Puts schedule for employee.Schedule import License is needed
    api_instance.put_schedule(body, employeeKeyName)
except ApiException as e:
    print("Exception when calling DailyOperationApi->putSchedule: %s\n" % e)

Parameters

Header parameters
Name Description
employeeKeyName*
String
One of persnr, badgenr, employeenr, registernr
Required
Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error • 5001 No Astrow License to access this option • 5002 Invalid date format • 5003 No key passed • 5004 Multiple employees found • 5005 Employees not found • 5006 Day program does not exists • 5007 General error • 5008 General error • 5000 Could not login in Astrow

Definition

deleteEmployee

Delete employee from Astrow and its associated user


/employee/{employeeid}/

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/employee/{employeeid}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefinitionApi;

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

public class DefinitionApiExample {

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

        DefinitionApi apiInstance = new DefinitionApi();
        String employeeid = employeeid_example; // String | The identifier employee to be deleted.
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        try {
            apiInstance.deleteEmployee(employeeid, employeeKeyName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefinitionApi#deleteEmployee");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefinitionApi;

public class DefinitionApiExample {

    public static void main(String[] args) {
        DefinitionApi apiInstance = new DefinitionApi();
        String employeeid = employeeid_example; // String | The identifier employee to be deleted.
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        try {
            apiInstance.deleteEmployee(employeeid, employeeKeyName);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefinitionApi#deleteEmployee");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *employeeid = employeeid_example; // The identifier employee to be deleted.
String *employeeKeyName = employeeKeyName_example; // One of persnr, badgenr, employeenr, registernr

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

// Delete employee from Astrow and its associated user
[apiInstance deleteEmployeeWith:employeeid
    employeeKeyName:employeeKeyName
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.DefinitionApi()
var employeeid = employeeid_example; // {{String}} The identifier employee to be deleted.
var employeeKeyName = employeeKeyName_example; // {{String}} One of persnr, badgenr, employeenr, registernr

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteEmployee(employeeid, employeeKeyName, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DefinitionApi();
            var employeeid = employeeid_example;  // String | The identifier employee to be deleted.
            var employeeKeyName = employeeKeyName_example;  // String | One of persnr, badgenr, employeenr, registernr

            try
            {
                // Delete employee from Astrow and its associated user
                apiInstance.deleteEmployee(employeeid, employeeKeyName);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefinitionApi.deleteEmployee: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiDefinitionApi();
$employeeid = employeeid_example; // String | The identifier employee to be deleted.
$employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr

try {
    $api_instance->deleteEmployee($employeeid, $employeeKeyName);
} catch (Exception $e) {
    echo 'Exception when calling DefinitionApi->deleteEmployee: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefinitionApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefinitionApi->new();
my $employeeid = employeeid_example; # String | The identifier employee to be deleted.
my $employeeKeyName = employeeKeyName_example; # String | One of persnr, badgenr, employeenr, registernr

eval { 
    $api_instance->deleteEmployee(employeeid => $employeeid, employeeKeyName => $employeeKeyName);
};
if ($@) {
    warn "Exception when calling DefinitionApi->deleteEmployee: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefinitionApi()
employeeid = employeeid_example # String | The identifier employee to be deleted.
employeeKeyName = employeeKeyName_example # String | One of persnr, badgenr, employeenr, registernr

try: 
    # Delete employee from Astrow and its associated user
    api_instance.delete_employee(employeeid, employeeKeyName)
except ApiException as e:
    print("Exception when calling DefinitionApi->deleteEmployee: %s\n" % e)

Parameters

Path parameters
Name Description
employeeid*
String
The identifier employee to be deleted.
Required
Header parameters
Name Description
employeeKeyName*
String
One of persnr, badgenr, employeenr, registernr
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error • 1000 Invalid employee key name • 1001 Invalid employee

patchEmployee

Patch employee. Import employee License is needed


/employee/{employeeid}/

Usage and SDK Samples

curl -X PATCH -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/employee/{employeeid}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefinitionApi;

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

public class DefinitionApiExample {

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

        DefinitionApi apiInstance = new DefinitionApi();
        Employee body = ; // Employee | 
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        String employeeid = employeeid_example; // String | The identifier employee to be patched.
        try {
            apiInstance.patchEmployee(body, employeeKeyName, employeeid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefinitionApi#patchEmployee");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefinitionApi;

public class DefinitionApiExample {

    public static void main(String[] args) {
        DefinitionApi apiInstance = new DefinitionApi();
        Employee body = ; // Employee | 
        String employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
        String employeeid = employeeid_example; // String | The identifier employee to be patched.
        try {
            apiInstance.patchEmployee(body, employeeKeyName, employeeid);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefinitionApi#patchEmployee");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Employee *body = ; // 
String *employeeKeyName = employeeKeyName_example; // One of persnr, badgenr, employeenr, registernr
String *employeeid = employeeid_example; // The identifier employee to be patched.

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

// Patch employee. Import employee License is needed
[apiInstance patchEmployeeWith:body
    employeeKeyName:employeeKeyName
    employeeid:employeeid
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.DefinitionApi()
var body = ; // {{Employee}} 
var employeeKeyName = employeeKeyName_example; // {{String}} One of persnr, badgenr, employeenr, registernr
var employeeid = employeeid_example; // {{String}} The identifier employee to be patched.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.patchEmployee(bodyemployeeKeyNameemployeeid, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DefinitionApi();
            var body = new Employee(); // Employee | 
            var employeeKeyName = employeeKeyName_example;  // String | One of persnr, badgenr, employeenr, registernr
            var employeeid = employeeid_example;  // String | The identifier employee to be patched.

            try
            {
                // Patch employee. Import employee License is needed
                apiInstance.patchEmployee(body, employeeKeyName, employeeid);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefinitionApi.patchEmployee: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiDefinitionApi();
$body = ; // Employee | 
$employeeKeyName = employeeKeyName_example; // String | One of persnr, badgenr, employeenr, registernr
$employeeid = employeeid_example; // String | The identifier employee to be patched.

try {
    $api_instance->patchEmployee($body, $employeeKeyName, $employeeid);
} catch (Exception $e) {
    echo 'Exception when calling DefinitionApi->patchEmployee: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefinitionApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefinitionApi->new();
my $body = WWW::SwaggerClient::Object::Employee->new(); # Employee | 
my $employeeKeyName = employeeKeyName_example; # String | One of persnr, badgenr, employeenr, registernr
my $employeeid = employeeid_example; # String | The identifier employee to be patched.

eval { 
    $api_instance->patchEmployee(body => $body, employeeKeyName => $employeeKeyName, employeeid => $employeeid);
};
if ($@) {
    warn "Exception when calling DefinitionApi->patchEmployee: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefinitionApi()
body =  # Employee | 
employeeKeyName = employeeKeyName_example # String | One of persnr, badgenr, employeenr, registernr
employeeid = employeeid_example # String | The identifier employee to be patched.

try: 
    # Patch employee. Import employee License is needed
    api_instance.patch_employee(body, employeeKeyName, employeeid)
except ApiException as e:
    print("Exception when calling DefinitionApi->patchEmployee: %s\n" % e)

Parameters

Path parameters
Name Description
employeeid*
String
The identifier employee to be patched.
Required
Header parameters
Name Description
employeeKeyName*
String
One of persnr, badgenr, employeenr, registernr
Required
Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error • 1000 Invalid employee key name • 1001 Invalid employee • 4000 Invalid badge • 4001 Pending change in progress • 4002 Cycle overlaps existing one • 4003 Paygroup overlaps existing one • 4004 Cycle not found • 4005 Paygroup not found • 4006 Company Site not found • 4007 Cost Group not found • 4008 Chop Group not found • 4009 Chop group overlaps existing one • 4010 Cost group overlaps existing one • 4011 Department overlaps existing one • 4012 Department not found

pullEmployees

Get all employees from Astrow


/employee

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/employee"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefinitionApi;

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

public class DefinitionApiExample {

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

        DefinitionApi apiInstance = new DefinitionApi();
        String dBLanguageField = dBLanguageField_example; // String | Astrow DB Language Field
        try {
            array[Employee] result = apiInstance.pullEmployees(dBLanguageField);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefinitionApi#pullEmployees");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefinitionApi;

public class DefinitionApiExample {

    public static void main(String[] args) {
        DefinitionApi apiInstance = new DefinitionApi();
        String dBLanguageField = dBLanguageField_example; // String | Astrow DB Language Field
        try {
            array[Employee] result = apiInstance.pullEmployees(dBLanguageField);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefinitionApi#pullEmployees");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *dBLanguageField = dBLanguageField_example; // Astrow DB Language Field

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

// Get all employees from Astrow
[apiInstance pullEmployeesWith:dBLanguageField
              completionHandler: ^(array[Employee] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.DefinitionApi()
var dBLanguageField = dBLanguageField_example; // {{String}} Astrow DB Language Field

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

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

            var apiInstance = new DefinitionApi();
            var dBLanguageField = dBLanguageField_example;  // String | Astrow DB Language Field

            try
            {
                // Get all employees from Astrow
                array[Employee] result = apiInstance.pullEmployees(dBLanguageField);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefinitionApi.pullEmployees: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiDefinitionApi();
$dBLanguageField = dBLanguageField_example; // String | Astrow DB Language Field

try {
    $result = $api_instance->pullEmployees($dBLanguageField);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefinitionApi->pullEmployees: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefinitionApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::DefinitionApi->new();
my $dBLanguageField = dBLanguageField_example; # String | Astrow DB Language Field

eval { 
    my $result = $api_instance->pullEmployees(dBLanguageField => $dBLanguageField);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefinitionApi->pullEmployees: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.DefinitionApi()
dBLanguageField = dBLanguageField_example # String | Astrow DB Language Field

try: 
    # Get all employees from Astrow
    api_response = api_instance.pull_employees(dBLanguageField)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefinitionApi->pullEmployees: %s\n" % e)

Parameters

Header parameters
Name Description
DBLanguageField*
String
Astrow DB Language Field
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

putEmployee

Add new employee. Import employee License is needed


/employee

Usage and SDK Samples

curl -X PUT -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/employee"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefinitionApi;

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

public class DefinitionApiExample {

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

        DefinitionApi apiInstance = new DefinitionApi();
        Employee body = ; // Employee | 
        try {
            apiInstance.putEmployee(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefinitionApi#putEmployee");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefinitionApi;

public class DefinitionApiExample {

    public static void main(String[] args) {
        DefinitionApi apiInstance = new DefinitionApi();
        Employee body = ; // Employee | 
        try {
            apiInstance.putEmployee(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefinitionApi#putEmployee");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Employee *body = ; // 

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

// Add new employee. Import employee License is needed
[apiInstance putEmployeeWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.DefinitionApi()
var body = ; // {{Employee}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.putEmployee(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new DefinitionApi();
            var body = new Employee(); // Employee | 

            try
            {
                // Add new employee. Import employee License is needed
                apiInstance.putEmployee(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefinitionApi.putEmployee: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiDefinitionApi();
$body = ; // Employee | 

try {
    $api_instance->putEmployee($body);
} catch (Exception $e) {
    echo 'Exception when calling DefinitionApi->putEmployee: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DefinitionApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->putEmployee(body => $body);
};
if ($@) {
    warn "Exception when calling DefinitionApi->putEmployee: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Add new employee. Import employee License is needed
    api_instance.put_employee(body)
except ApiException as e:
    print("Exception when calling DefinitionApi->putEmployee: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error • 1000 Invalid employee key name • 1001 Invalid employee • 4000 Invalid badge • 4001 Pending change in progress • 4002 Cycle overlaps existing one • 4003 Paygroup overlaps existing one • 4004 Cycle not found • 4005 Paygroup not found • 4006 Company Site not found • 4007 Cost Group not found • 4008 Chop Group not found • 4009 Chop group overlaps existing one • 4010 Cost group overlaps existing one • 4011 Department overlaps existing one • 4012 Department not found

ExportService

pullAbsences

Pulls all new operations on the absences performed since last call of pullAbsences(). For initial setup, if needed, Amano has to process old Absences in order to be exported.


/absences

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/absences"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExportServiceApi;

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

public class ExportServiceApiExample {

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

        ExportServiceApi apiInstance = new ExportServiceApi();
        try {
            array[AbsenceOperation] result = apiInstance.pullAbsences();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExportServiceApi#pullAbsences");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ExportServiceApi;

public class ExportServiceApiExample {

    public static void main(String[] args) {
        ExportServiceApi apiInstance = new ExportServiceApi();
        try {
            array[AbsenceOperation] result = apiInstance.pullAbsences();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExportServiceApi#pullAbsences");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

// Pulls all new operations on the absences performed since last call of pullAbsences(). For initial setup, if needed, Amano has to process old Absences in order to be exported.
[apiInstance pullAbsencesWithCompletionHandler: 
              ^(array[AbsenceOperation] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ExportServiceApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.pullAbsences(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ExportServiceApi();

            try
            {
                // Pulls all new operations on the absences performed since last call of pullAbsences(). For initial setup, if needed, Amano has to process old Absences in order to be exported.
                array[AbsenceOperation] result = apiInstance.pullAbsences();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExportServiceApi.pullAbsences: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiExportServiceApi();

try {
    $result = $api_instance->pullAbsences();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExportServiceApi->pullAbsences: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExportServiceApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ExportServiceApi->new();

eval { 
    my $result = $api_instance->pullAbsences();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExportServiceApi->pullAbsences: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ExportServiceApi()

try: 
    # Pulls all new operations on the absences performed since last call of pullAbsences(). For initial setup, if needed, Amano has to process old Absences in order to be exported.
    api_response = api_instance.pull_absences()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExportServiceApi->pullAbsences: %s\n" % e)

Parameters

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

pullBookings

Get the bookings based on start and end date. Maximum interval of days is 15. When connected to a lower version of Astrow than 11.2, start date and end date will be ignored. It will retrieve bookings based on the Web.config setting BookingsExportPastDaysNumber relative to current date


/booking

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/booking?startDate=&endDate=&includesynced="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExportServiceApi;

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

public class ExportServiceApiExample {

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

        ExportServiceApi apiInstance = new ExportServiceApi();
        String startDate = startDate_example; // String | Start date YYYY-mm-dd format
        String endDate = endDate_example; // String | End date YYYY-mm-dd format
        String includesynced = includesynced_example; // String | Include already synced.
        try {
            array[Bookings] result = apiInstance.pullBookings(startDate, endDate, includesynced);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExportServiceApi#pullBookings");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ExportServiceApi;

public class ExportServiceApiExample {

    public static void main(String[] args) {
        ExportServiceApi apiInstance = new ExportServiceApi();
        String startDate = startDate_example; // String | Start date YYYY-mm-dd format
        String endDate = endDate_example; // String | End date YYYY-mm-dd format
        String includesynced = includesynced_example; // String | Include already synced.
        try {
            array[Bookings] result = apiInstance.pullBookings(startDate, endDate, includesynced);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExportServiceApi#pullBookings");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *startDate = startDate_example; // Start date YYYY-mm-dd format
String *endDate = endDate_example; // End date YYYY-mm-dd format
String *includesynced = includesynced_example; // Include already synced.

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

// Get the bookings based on start and end date. Maximum interval of days is 15. When connected to a lower version of Astrow than 11.2, start date and end date will be ignored.

 It will retrieve bookings based on the Web.config setting BookingsExportPastDaysNumber relative to current date
[apiInstance pullBookingsWith:startDate
    endDate:endDate
    includesynced:includesynced
              completionHandler: ^(array[Bookings] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ExportServiceApi()
var startDate = startDate_example; // {{String}} Start date YYYY-mm-dd format
var endDate = endDate_example; // {{String}} End date YYYY-mm-dd format
var includesynced = includesynced_example; // {{String}} Include already synced.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.pullBookings(startDate, endDate, includesynced, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ExportServiceApi();
            var startDate = startDate_example;  // String | Start date YYYY-mm-dd format
            var endDate = endDate_example;  // String | End date YYYY-mm-dd format
            var includesynced = includesynced_example;  // String | Include already synced.

            try
            {
                // Get the bookings based on start and end date. Maximum interval of days is 15. When connected to a lower version of Astrow than 11.2, start date and end date will be ignored.

 It will retrieve bookings based on the Web.config setting BookingsExportPastDaysNumber relative to current date
                array[Bookings] result = apiInstance.pullBookings(startDate, endDate, includesynced);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExportServiceApi.pullBookings: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiExportServiceApi();
$startDate = startDate_example; // String | Start date YYYY-mm-dd format
$endDate = endDate_example; // String | End date YYYY-mm-dd format
$includesynced = includesynced_example; // String | Include already synced.

try {
    $result = $api_instance->pullBookings($startDate, $endDate, $includesynced);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExportServiceApi->pullBookings: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExportServiceApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ExportServiceApi->new();
my $startDate = startDate_example; # String | Start date YYYY-mm-dd format
my $endDate = endDate_example; # String | End date YYYY-mm-dd format
my $includesynced = includesynced_example; # String | Include already synced.

eval { 
    my $result = $api_instance->pullBookings(startDate => $startDate, endDate => $endDate, includesynced => $includesynced);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExportServiceApi->pullBookings: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ExportServiceApi()
startDate = startDate_example # String | Start date YYYY-mm-dd format
endDate = endDate_example # String | End date YYYY-mm-dd format
includesynced = includesynced_example # String | Include already synced.

try: 
    # Get the bookings based on start and end date. Maximum interval of days is 15. When connected to a lower version of Astrow than 11.2, start date and end date will be ignored.

 It will retrieve bookings based on the Web.config setting BookingsExportPastDaysNumber relative to current date
    api_response = api_instance.pull_bookings(startDate, endDate, includesynced)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExportServiceApi->pullBookings: %s\n" % e)

Parameters

Query parameters
Name Description
startDate*
String
Start date YYYY-mm-dd format
Required
endDate*
String
End date YYYY-mm-dd format
Required
includesynced*
String
Include already synced.
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

pullDailyCounter

Get the bookings based on start and end date. Maximum interval of days is 15. When connected to a lower version of Astrow than 11.2, start date and end date will be ignored. It will retrieve bookings based on the Web.config setting BookingsExportPastDaysNumber relative to current date


/dailycounter

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/dailycounter"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExportServiceApi;

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

public class ExportServiceApiExample {

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

        ExportServiceApi apiInstance = new ExportServiceApi();
        String startDate = startDate_example; // String | Start date YYYY-mm-dd format
        String endDate = endDate_example; // String | End date YYYY-mm-dd format
        String teams = teams_example; // String | Team names, comma separated
        String counters = counters_example; // String | Counter codes
        try {
            array[Counter] result = apiInstance.pullDailyCounter(startDate, endDate, teams, counters);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExportServiceApi#pullDailyCounter");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ExportServiceApi;

public class ExportServiceApiExample {

    public static void main(String[] args) {
        ExportServiceApi apiInstance = new ExportServiceApi();
        String startDate = startDate_example; // String | Start date YYYY-mm-dd format
        String endDate = endDate_example; // String | End date YYYY-mm-dd format
        String teams = teams_example; // String | Team names, comma separated
        String counters = counters_example; // String | Counter codes
        try {
            array[Counter] result = apiInstance.pullDailyCounter(startDate, endDate, teams, counters);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExportServiceApi#pullDailyCounter");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *startDate = startDate_example; // Start date YYYY-mm-dd format
String *endDate = endDate_example; // End date YYYY-mm-dd format
String *teams = teams_example; // Team names, comma separated
String *counters = counters_example; // Counter codes

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

// Get the bookings based on start and end date. Maximum interval of days is 15. When connected to a lower version of Astrow than 11.2, start date and end date will be ignored.

 It will retrieve bookings based on the Web.config setting BookingsExportPastDaysNumber relative to current date
[apiInstance pullDailyCounterWith:startDate
    endDate:endDate
    teams:teams
    counters:counters
              completionHandler: ^(array[Counter] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ExportServiceApi()
var startDate = startDate_example; // {{String}} Start date YYYY-mm-dd format
var endDate = endDate_example; // {{String}} End date YYYY-mm-dd format
var teams = teams_example; // {{String}} Team names, comma separated
var counters = counters_example; // {{String}} Counter codes

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.pullDailyCounter(startDate, endDate, teams, counters, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ExportServiceApi();
            var startDate = startDate_example;  // String | Start date YYYY-mm-dd format
            var endDate = endDate_example;  // String | End date YYYY-mm-dd format
            var teams = teams_example;  // String | Team names, comma separated
            var counters = counters_example;  // String | Counter codes

            try
            {
                // Get the bookings based on start and end date. Maximum interval of days is 15. When connected to a lower version of Astrow than 11.2, start date and end date will be ignored.

 It will retrieve bookings based on the Web.config setting BookingsExportPastDaysNumber relative to current date
                array[Counter] result = apiInstance.pullDailyCounter(startDate, endDate, teams, counters);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExportServiceApi.pullDailyCounter: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiExportServiceApi();
$startDate = startDate_example; // String | Start date YYYY-mm-dd format
$endDate = endDate_example; // String | End date YYYY-mm-dd format
$teams = teams_example; // String | Team names, comma separated
$counters = counters_example; // String | Counter codes

try {
    $result = $api_instance->pullDailyCounter($startDate, $endDate, $teams, $counters);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExportServiceApi->pullDailyCounter: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExportServiceApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ExportServiceApi->new();
my $startDate = startDate_example; # String | Start date YYYY-mm-dd format
my $endDate = endDate_example; # String | End date YYYY-mm-dd format
my $teams = teams_example; # String | Team names, comma separated
my $counters = counters_example; # String | Counter codes

eval { 
    my $result = $api_instance->pullDailyCounter(startDate => $startDate, endDate => $endDate, teams => $teams, counters => $counters);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExportServiceApi->pullDailyCounter: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ExportServiceApi()
startDate = startDate_example # String | Start date YYYY-mm-dd format
endDate = endDate_example # String | End date YYYY-mm-dd format
teams = teams_example # String | Team names, comma separated
counters = counters_example # String | Counter codes

try: 
    # Get the bookings based on start and end date. Maximum interval of days is 15. When connected to a lower version of Astrow than 11.2, start date and end date will be ignored.

 It will retrieve bookings based on the Web.config setting BookingsExportPastDaysNumber relative to current date
    api_response = api_instance.pull_daily_counter(startDate, endDate, teams, counters)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExportServiceApi->pullDailyCounter: %s\n" % e)

Parameters

Header parameters
Name Description
startDate*
String
Start date YYYY-mm-dd format
Required
endDate*
String
End date YYYY-mm-dd format
Required
teams*
String
Team names, comma separated
Required
counters*
String
Counter codes
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

scheduleGet

Get the planned schedule for specifield employees and interval


/schedule

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/schedule"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ExportServiceApi;

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

public class ExportServiceApiExample {

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

        ExportServiceApi apiInstance = new ExportServiceApi();
        String startDate = startDate_example; // String | Start date, in YYYY-mm-dd format
        String endDate = endDate_example; // String | End date, in YYYY-mm-dd format
        String teams = teams_example; // String | Team names, comma separated
        try {
            array[DailySchedule] result = apiInstance.scheduleGet(startDate, endDate, teams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExportServiceApi#scheduleGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ExportServiceApi;

public class ExportServiceApiExample {

    public static void main(String[] args) {
        ExportServiceApi apiInstance = new ExportServiceApi();
        String startDate = startDate_example; // String | Start date, in YYYY-mm-dd format
        String endDate = endDate_example; // String | End date, in YYYY-mm-dd format
        String teams = teams_example; // String | Team names, comma separated
        try {
            array[DailySchedule] result = apiInstance.scheduleGet(startDate, endDate, teams);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ExportServiceApi#scheduleGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *startDate = startDate_example; // Start date, in YYYY-mm-dd format
String *endDate = endDate_example; // End date, in YYYY-mm-dd format
String *teams = teams_example; // Team names, comma separated

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

// Get the planned schedule for specifield employees and interval
[apiInstance scheduleGetWith:startDate
    endDate:endDate
    teams:teams
              completionHandler: ^(array[DailySchedule] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ExportServiceApi()
var startDate = startDate_example; // {{String}} Start date, in YYYY-mm-dd format
var endDate = endDate_example; // {{String}} End date, in YYYY-mm-dd format
var teams = teams_example; // {{String}} Team names, comma separated

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.scheduleGet(startDate, endDate, teams, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ExportServiceApi();
            var startDate = startDate_example;  // String | Start date, in YYYY-mm-dd format
            var endDate = endDate_example;  // String | End date, in YYYY-mm-dd format
            var teams = teams_example;  // String | Team names, comma separated

            try
            {
                // Get the planned schedule for specifield employees and interval
                array[DailySchedule] result = apiInstance.scheduleGet(startDate, endDate, teams);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ExportServiceApi.scheduleGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiExportServiceApi();
$startDate = startDate_example; // String | Start date, in YYYY-mm-dd format
$endDate = endDate_example; // String | End date, in YYYY-mm-dd format
$teams = teams_example; // String | Team names, comma separated

try {
    $result = $api_instance->scheduleGet($startDate, $endDate, $teams);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ExportServiceApi->scheduleGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ExportServiceApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ExportServiceApi->new();
my $startDate = startDate_example; # String | Start date, in YYYY-mm-dd format
my $endDate = endDate_example; # String | End date, in YYYY-mm-dd format
my $teams = teams_example; # String | Team names, comma separated

eval { 
    my $result = $api_instance->scheduleGet(startDate => $startDate, endDate => $endDate, teams => $teams);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ExportServiceApi->scheduleGet: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ExportServiceApi()
startDate = startDate_example # String | Start date, in YYYY-mm-dd format
endDate = endDate_example # String | End date, in YYYY-mm-dd format
teams = teams_example # String | Team names, comma separated

try: 
    # Get the planned schedule for specifield employees and interval
    api_response = api_instance.schedule_get(startDate, endDate, teams)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ExportServiceApi->scheduleGet: %s\n" % e)

Parameters

Header parameters
Name Description
startDate*
String
Start date, in YYYY-mm-dd format
Required
endDate*
String
End date, in YYYY-mm-dd format
Required
teams*
String
Team names, comma separated
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

Project

activityCreate

Add a new activity


/activity

Usage and SDK Samples

curl -X PUT -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/activity"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        Activity body = ; // Activity | 
        try {
            apiInstance.activityCreate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#activityCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        Activity body = ; // Activity | 
        try {
            apiInstance.activityCreate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#activityCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Activity *body = ; // 

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

// Add a new activity
[apiInstance activityCreateWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var body = ; // {{Activity}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activityCreate(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var body = new Activity(); // Activity | 

            try
            {
                // Add a new activity
                apiInstance.activityCreate(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.activityCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$body = ; // Activity | 

try {
    $api_instance->activityCreate($body);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->activityCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->activityCreate(body => $body);
};
if ($@) {
    warn "Exception when calling ProjectApi->activityCreate: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Add a new activity
    api_instance.activity_create(body)
except ApiException as e:
    print("Exception when calling ProjectApi->activityCreate: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 9000 Internal Server error • 90001 Invalid parameters • 90003 Missing project license • 90000 User has no permission to run API • 10 Name must be unique • 7003 Provided code must be unique • 7002 Provided counter code is invalid

activityDelete

Mark the activity as deleted


/activity/{activityCode}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/activity/{activityCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String activityCode = activityCode_example; // String | The code of activity to delete.
        try {
            apiInstance.activityDelete(activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#activityDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String activityCode = activityCode_example; // String | The code of activity to delete.
        try {
            apiInstance.activityDelete(activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#activityDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *activityCode = activityCode_example; // The code of activity to delete.

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

// Mark the activity as deleted
[apiInstance activityDeleteWith:activityCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var activityCode = activityCode_example; // {{String}} The code of activity to delete.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activityDelete(activityCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var activityCode = activityCode_example;  // String | The code of activity to delete.

            try
            {
                // Mark the activity as deleted
                apiInstance.activityDelete(activityCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.activityDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$activityCode = activityCode_example; // String | The code of activity to delete.

try {
    $api_instance->activityDelete($activityCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->activityDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $activityCode = activityCode_example; # String | The code of activity to delete.

eval { 
    $api_instance->activityDelete(activityCode => $activityCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->activityDelete: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
activityCode = activityCode_example # String | The code of activity to delete.

try: 
    # Mark the activity as deleted
    api_instance.activity_delete(activityCode)
except ApiException as e:
    print("Exception when calling ProjectApi->activityDelete: %s\n" % e)

Parameters

Path parameters
Name Description
activityCode*
String
The code of activity to delete.
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 9000 Internal Server error • 90003 Missing project license • 90000 User has no permission to run API • 90001 Invalid parameters

activityGet

Get all activities from Astrow


/activity

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/activity"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        try {
            array[Activity] result = apiInstance.activityGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#activityGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        try {
            array[Activity] result = apiInstance.activityGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#activityGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

// Get all activities from Astrow
[apiInstance activityGetWithCompletionHandler: 
              ^(array[Activity] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.activityGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();

            try
            {
                // Get all activities from Astrow
                array[Activity] result = apiInstance.activityGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.activityGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();

try {
    $result = $api_instance->activityGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->activityGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();

eval { 
    my $result = $api_instance->activityGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectApi->activityGet: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()

try: 
    # Get all activities from Astrow
    api_response = api_instance.activity_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectApi->activityGet: %s\n" % e)

Parameters

Responses

Status: 200

OK

Status: 400

Error codes: • 9000 Internal Server error • 90003 Missing project license • 90000 User has no permission to run API

activityUpdate

Patch the activity


/activity/{activityCode}

Usage and SDK Samples

curl -X PATCH -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/activity/{activityCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        Activity body = ; // Activity | 
        String activityCode = activityCode_example; // String | The code of the activity to update.
        try {
            apiInstance.activityUpdate(body, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#activityUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        Activity body = ; // Activity | 
        String activityCode = activityCode_example; // String | The code of the activity to update.
        try {
            apiInstance.activityUpdate(body, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#activityUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Activity *body = ; // 
String *activityCode = activityCode_example; // The code of the activity to update.

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

// Patch the activity
[apiInstance activityUpdateWith:body
    activityCode:activityCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var body = ; // {{Activity}} 
var activityCode = activityCode_example; // {{String}} The code of the activity to update.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.activityUpdate(bodyactivityCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var body = new Activity(); // Activity | 
            var activityCode = activityCode_example;  // String | The code of the activity to update.

            try
            {
                // Patch the activity
                apiInstance.activityUpdate(body, activityCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.activityUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$body = ; // Activity | 
$activityCode = activityCode_example; // String | The code of the activity to update.

try {
    $api_instance->activityUpdate($body, $activityCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->activityUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $body = WWW::SwaggerClient::Object::Activity->new(); # Activity | 
my $activityCode = activityCode_example; # String | The code of the activity to update.

eval { 
    $api_instance->activityUpdate(body => $body, activityCode => $activityCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->activityUpdate: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
body =  # Activity | 
activityCode = activityCode_example # String | The code of the activity to update.

try: 
    # Patch the activity
    api_instance.activity_update(body, activityCode)
except ApiException as e:
    print("Exception when calling ProjectApi->activityUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
activityCode*
String
The code of the activity to update.
Required
Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 9000 Internal Server error • 90001 Invalid parameters • 90003 Missing project license • 90000 User has no permission to run API • 10 Name must be unique • 7003 Provided code must be unique • 7002 Provided counter code is invalid

componentCreate

Add a new component


/component

Usage and SDK Samples

curl -X PUT -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/component"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        Component body = ; // Component | 
        try {
            apiInstance.componentCreate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#componentCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        Component body = ; // Component | 
        try {
            apiInstance.componentCreate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#componentCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Component *body = ; // 

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

// Add a new component
[apiInstance componentCreateWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var body = ; // {{Component}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.componentCreate(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var body = new Component(); // Component | 

            try
            {
                // Add a new component
                apiInstance.componentCreate(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.componentCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$body = ; // Component | 

try {
    $api_instance->componentCreate($body);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->componentCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->componentCreate(body => $body);
};
if ($@) {
    warn "Exception when calling ProjectApi->componentCreate: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Add a new component
    api_instance.component_create(body)
except ApiException as e:
    print("Exception when calling ProjectApi->componentCreate: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 9000 Internal Server error • 90001 Invalid parameters • 90003 Missing project license • 90000 User has no permission to run API • 10 Name must be unique • 7003 Provided code must be unique

componentDelete

Mark the component as deleted


/component/{componentCode}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/component/{componentCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String componentCode = componentCode_example; // String | The code of component to delete.
        try {
            apiInstance.componentDelete(componentCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#componentDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String componentCode = componentCode_example; // String | The code of component to delete.
        try {
            apiInstance.componentDelete(componentCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#componentDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *componentCode = componentCode_example; // The code of component to delete.

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

// Mark the component as deleted
[apiInstance componentDeleteWith:componentCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var componentCode = componentCode_example; // {{String}} The code of component to delete.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.componentDelete(componentCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var componentCode = componentCode_example;  // String | The code of component to delete.

            try
            {
                // Mark the component as deleted
                apiInstance.componentDelete(componentCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.componentDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$componentCode = componentCode_example; // String | The code of component to delete.

try {
    $api_instance->componentDelete($componentCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->componentDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $componentCode = componentCode_example; # String | The code of component to delete.

eval { 
    $api_instance->componentDelete(componentCode => $componentCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->componentDelete: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
componentCode = componentCode_example # String | The code of component to delete.

try: 
    # Mark the component as deleted
    api_instance.component_delete(componentCode)
except ApiException as e:
    print("Exception when calling ProjectApi->componentDelete: %s\n" % e)

Parameters

Path parameters
Name Description
componentCode*
String
The code of component to delete.
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 9000 Internal Server error • 90003 Missing project license • 90000 User has no permission to run API • 90001 Invalid parameters

componentGet

Get all components from Astrow


/component

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/component"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        try {
            array[Component] result = apiInstance.componentGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#componentGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        try {
            array[Component] result = apiInstance.componentGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#componentGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

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

// Get all components from Astrow
[apiInstance componentGetWithCompletionHandler: 
              ^(array[Component] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.componentGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();

            try
            {
                // Get all components from Astrow
                array[Component] result = apiInstance.componentGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.componentGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();

try {
    $result = $api_instance->componentGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->componentGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();

eval { 
    my $result = $api_instance->componentGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectApi->componentGet: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()

try: 
    # Get all components from Astrow
    api_response = api_instance.component_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectApi->componentGet: %s\n" % e)

Parameters

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

componentUpdate

Patch the component


/component/{componentCode}

Usage and SDK Samples

curl -X PATCH -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/component/{componentCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        Component body = ; // Component | 
        String componentCode = componentCode_example; // String | The code of the component to update.
        try {
            apiInstance.componentUpdate(body, componentCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#componentUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        Component body = ; // Component | 
        String componentCode = componentCode_example; // String | The code of the component to update.
        try {
            apiInstance.componentUpdate(body, componentCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#componentUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Component *body = ; // 
String *componentCode = componentCode_example; // The code of the component to update.

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

// Patch the component
[apiInstance componentUpdateWith:body
    componentCode:componentCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var body = ; // {{Component}} 
var componentCode = componentCode_example; // {{String}} The code of the component to update.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.componentUpdate(bodycomponentCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var body = new Component(); // Component | 
            var componentCode = componentCode_example;  // String | The code of the component to update.

            try
            {
                // Patch the component
                apiInstance.componentUpdate(body, componentCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.componentUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$body = ; // Component | 
$componentCode = componentCode_example; // String | The code of the component to update.

try {
    $api_instance->componentUpdate($body, $componentCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->componentUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $body = WWW::SwaggerClient::Object::Component->new(); # Component | 
my $componentCode = componentCode_example; # String | The code of the component to update.

eval { 
    $api_instance->componentUpdate(body => $body, componentCode => $componentCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->componentUpdate: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
body =  # Component | 
componentCode = componentCode_example # String | The code of the component to update.

try: 
    # Patch the component
    api_instance.component_update(body, componentCode)
except ApiException as e:
    print("Exception when calling ProjectApi->componentUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
componentCode*
String
The code of the component to update.
Required
Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 9000 Internal Server error • 90003 Missing project license • 90000 User has no permission to run API • 90001 Invalid parameters

projectBookingGet

Get the project bookings based on start and end date. Maximum interval of days is 15.


/project/booking

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project/booking?startDate=&endDate=&includesynced="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String startDate = startDate_example; // String | Start date YYYY-mm-dd format
        String endDate = endDate_example; // String | End date YYYY-mm-dd format
        String includesynced = includesynced_example; // String | Include already synced.
        try {
            array[ProjectBookings] result = apiInstance.projectBookingGet(startDate, endDate, includesynced);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectBookingGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String startDate = startDate_example; // String | Start date YYYY-mm-dd format
        String endDate = endDate_example; // String | End date YYYY-mm-dd format
        String includesynced = includesynced_example; // String | Include already synced.
        try {
            array[ProjectBookings] result = apiInstance.projectBookingGet(startDate, endDate, includesynced);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectBookingGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *startDate = startDate_example; // Start date YYYY-mm-dd format
String *endDate = endDate_example; // End date YYYY-mm-dd format
String *includesynced = includesynced_example; // Include already synced.

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

// Get the project bookings based on start and end date. Maximum interval of days is 15.
[apiInstance projectBookingGetWith:startDate
    endDate:endDate
    includesynced:includesynced
              completionHandler: ^(array[ProjectBookings] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var startDate = startDate_example; // {{String}} Start date YYYY-mm-dd format
var endDate = endDate_example; // {{String}} End date YYYY-mm-dd format
var includesynced = includesynced_example; // {{String}} Include already synced.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.projectBookingGet(startDate, endDate, includesynced, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var startDate = startDate_example;  // String | Start date YYYY-mm-dd format
            var endDate = endDate_example;  // String | End date YYYY-mm-dd format
            var includesynced = includesynced_example;  // String | Include already synced.

            try
            {
                // Get the project bookings based on start and end date. Maximum interval of days is 15.
                array[ProjectBookings] result = apiInstance.projectBookingGet(startDate, endDate, includesynced);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectBookingGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$startDate = startDate_example; // String | Start date YYYY-mm-dd format
$endDate = endDate_example; // String | End date YYYY-mm-dd format
$includesynced = includesynced_example; // String | Include already synced.

try {
    $result = $api_instance->projectBookingGet($startDate, $endDate, $includesynced);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectBookingGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $startDate = startDate_example; # String | Start date YYYY-mm-dd format
my $endDate = endDate_example; # String | End date YYYY-mm-dd format
my $includesynced = includesynced_example; # String | Include already synced.

eval { 
    my $result = $api_instance->projectBookingGet(startDate => $startDate, endDate => $endDate, includesynced => $includesynced);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectBookingGet: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
startDate = startDate_example # String | Start date YYYY-mm-dd format
endDate = endDate_example # String | End date YYYY-mm-dd format
includesynced = includesynced_example # String | Include already synced.

try: 
    # Get the project bookings based on start and end date. Maximum interval of days is 15.
    api_response = api_instance.project_booking_get(startDate, endDate, includesynced)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectApi->projectBookingGet: %s\n" % e)

Parameters

Query parameters
Name Description
startDate*
String
Start date YYYY-mm-dd format
Required
endDate*
String
End date YYYY-mm-dd format
Required
includesynced*
String
Include already synced.
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

projectComponentAssignLevel1

Assign to the project the activity


/project/{projectCode}/activity/{activityCode}

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project/{projectCode}/activity/{activityCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | 
        String activityCode = activityCode_example; // String | 
        try {
            apiInstance.projectComponentAssignLevel1(projectCode, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectComponentAssignLevel1");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | 
        String activityCode = activityCode_example; // String | 
        try {
            apiInstance.projectComponentAssignLevel1(projectCode, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectComponentAssignLevel1");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *projectCode = projectCode_example; // 
String *activityCode = activityCode_example; // 

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

// Assign to the project the activity
[apiInstance projectComponentAssignLevel1With:projectCode
    activityCode:activityCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var projectCode = projectCode_example; // {{String}} 
var activityCode = activityCode_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.projectComponentAssignLevel1(projectCode, activityCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var projectCode = projectCode_example;  // String | 
            var activityCode = activityCode_example;  // String | 

            try
            {
                // Assign to the project the activity
                apiInstance.projectComponentAssignLevel1(projectCode, activityCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectComponentAssignLevel1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$projectCode = projectCode_example; // String | 
$activityCode = activityCode_example; // String | 

try {
    $api_instance->projectComponentAssignLevel1($projectCode, $activityCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectComponentAssignLevel1: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $projectCode = projectCode_example; # String | 
my $activityCode = activityCode_example; # String | 

eval { 
    $api_instance->projectComponentAssignLevel1(projectCode => $projectCode, activityCode => $activityCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectComponentAssignLevel1: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
projectCode = projectCode_example # String | 
activityCode = activityCode_example # String | 

try: 
    # Assign to the project the activity
    api_instance.project_component_assign_level1(projectCode, activityCode)
except ApiException as e:
    print("Exception when calling ProjectApi->projectComponentAssignLevel1: %s\n" % e)

Parameters

Path parameters
Name Description
projectCode*
String
Required
activityCode*
String
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

projectComponentAssignLevel2

Assign to the project the specified components & activity


/project/{projectCode}/component/{componentCode1}/activity/{activityCode}

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project/{projectCode}/component/{componentCode1}/activity/{activityCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | 
        String componentCode1 = componentCode1_example; // String | 
        String activityCode = activityCode_example; // String | 
        try {
            apiInstance.projectComponentAssignLevel2(projectCode, componentCode1, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectComponentAssignLevel2");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | 
        String componentCode1 = componentCode1_example; // String | 
        String activityCode = activityCode_example; // String | 
        try {
            apiInstance.projectComponentAssignLevel2(projectCode, componentCode1, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectComponentAssignLevel2");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *projectCode = projectCode_example; // 
String *componentCode1 = componentCode1_example; // 
String *activityCode = activityCode_example; // 

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

// Assign to the project the specified components & activity
[apiInstance projectComponentAssignLevel2With:projectCode
    componentCode1:componentCode1
    activityCode:activityCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var projectCode = projectCode_example; // {{String}} 
var componentCode1 = componentCode1_example; // {{String}} 
var activityCode = activityCode_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.projectComponentAssignLevel2(projectCode, componentCode1, activityCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var projectCode = projectCode_example;  // String | 
            var componentCode1 = componentCode1_example;  // String | 
            var activityCode = activityCode_example;  // String | 

            try
            {
                // Assign to the project the specified components & activity
                apiInstance.projectComponentAssignLevel2(projectCode, componentCode1, activityCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectComponentAssignLevel2: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$projectCode = projectCode_example; // String | 
$componentCode1 = componentCode1_example; // String | 
$activityCode = activityCode_example; // String | 

try {
    $api_instance->projectComponentAssignLevel2($projectCode, $componentCode1, $activityCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectComponentAssignLevel2: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $projectCode = projectCode_example; # String | 
my $componentCode1 = componentCode1_example; # String | 
my $activityCode = activityCode_example; # String | 

eval { 
    $api_instance->projectComponentAssignLevel2(projectCode => $projectCode, componentCode1 => $componentCode1, activityCode => $activityCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectComponentAssignLevel2: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
projectCode = projectCode_example # String | 
componentCode1 = componentCode1_example # String | 
activityCode = activityCode_example # String | 

try: 
    # Assign to the project the specified components & activity
    api_instance.project_component_assign_level2(projectCode, componentCode1, activityCode)
except ApiException as e:
    print("Exception when calling ProjectApi->projectComponentAssignLevel2: %s\n" % e)

Parameters

Path parameters
Name Description
projectCode*
String
Required
componentCode1*
String
Required
activityCode*
String
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

projectComponentAssignLevel3

Assign to the project the specified components & activity


/project/{projectCode}/component/{componentCode1}/{componentCode2}/activity/{activityCode}

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project/{projectCode}/component/{componentCode1}/{componentCode2}/activity/{activityCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | 
        String componentCode1 = componentCode1_example; // String | 
        String componentCode2 = componentCode2_example; // String | 
        String activityCode = activityCode_example; // String | 
        try {
            apiInstance.projectComponentAssignLevel3(projectCode, componentCode1, componentCode2, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectComponentAssignLevel3");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | 
        String componentCode1 = componentCode1_example; // String | 
        String componentCode2 = componentCode2_example; // String | 
        String activityCode = activityCode_example; // String | 
        try {
            apiInstance.projectComponentAssignLevel3(projectCode, componentCode1, componentCode2, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectComponentAssignLevel3");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *projectCode = projectCode_example; // 
String *componentCode1 = componentCode1_example; // 
String *componentCode2 = componentCode2_example; // 
String *activityCode = activityCode_example; // 

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

// Assign to the project the specified components & activity
[apiInstance projectComponentAssignLevel3With:projectCode
    componentCode1:componentCode1
    componentCode2:componentCode2
    activityCode:activityCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var projectCode = projectCode_example; // {{String}} 
var componentCode1 = componentCode1_example; // {{String}} 
var componentCode2 = componentCode2_example; // {{String}} 
var activityCode = activityCode_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.projectComponentAssignLevel3(projectCode, componentCode1, componentCode2, activityCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var projectCode = projectCode_example;  // String | 
            var componentCode1 = componentCode1_example;  // String | 
            var componentCode2 = componentCode2_example;  // String | 
            var activityCode = activityCode_example;  // String | 

            try
            {
                // Assign to the project the specified components & activity
                apiInstance.projectComponentAssignLevel3(projectCode, componentCode1, componentCode2, activityCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectComponentAssignLevel3: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$projectCode = projectCode_example; // String | 
$componentCode1 = componentCode1_example; // String | 
$componentCode2 = componentCode2_example; // String | 
$activityCode = activityCode_example; // String | 

try {
    $api_instance->projectComponentAssignLevel3($projectCode, $componentCode1, $componentCode2, $activityCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectComponentAssignLevel3: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $projectCode = projectCode_example; # String | 
my $componentCode1 = componentCode1_example; # String | 
my $componentCode2 = componentCode2_example; # String | 
my $activityCode = activityCode_example; # String | 

eval { 
    $api_instance->projectComponentAssignLevel3(projectCode => $projectCode, componentCode1 => $componentCode1, componentCode2 => $componentCode2, activityCode => $activityCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectComponentAssignLevel3: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
projectCode = projectCode_example # String | 
componentCode1 = componentCode1_example # String | 
componentCode2 = componentCode2_example # String | 
activityCode = activityCode_example # String | 

try: 
    # Assign to the project the specified components & activity
    api_instance.project_component_assign_level3(projectCode, componentCode1, componentCode2, activityCode)
except ApiException as e:
    print("Exception when calling ProjectApi->projectComponentAssignLevel3: %s\n" % e)

Parameters

Path parameters
Name Description
projectCode*
String
Required
componentCode1*
String
Required
componentCode2*
String
Required
activityCode*
String
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

projectComponentAssignLevel4

Assign to the project the specified components & activity


/project/{projectCode}/component/{componentCode1}/{componentCode2}/{componentCode3}/activity/{activityCode}

Usage and SDK Samples

curl -X POST -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project/{projectCode}/component/{componentCode1}/{componentCode2}/{componentCode3}/activity/{activityCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | 
        String componentCode1 = componentCode1_example; // String | 
        String componentCode2 = componentCode2_example; // String | 
        String componentCode3 = componentCode3_example; // String | 
        String activityCode = activityCode_example; // String | 
        try {
            apiInstance.projectComponentAssignLevel4(projectCode, componentCode1, componentCode2, componentCode3, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectComponentAssignLevel4");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | 
        String componentCode1 = componentCode1_example; // String | 
        String componentCode2 = componentCode2_example; // String | 
        String componentCode3 = componentCode3_example; // String | 
        String activityCode = activityCode_example; // String | 
        try {
            apiInstance.projectComponentAssignLevel4(projectCode, componentCode1, componentCode2, componentCode3, activityCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectComponentAssignLevel4");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *projectCode = projectCode_example; // 
String *componentCode1 = componentCode1_example; // 
String *componentCode2 = componentCode2_example; // 
String *componentCode3 = componentCode3_example; // 
String *activityCode = activityCode_example; // 

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

// Assign to the project the specified components & activity
[apiInstance projectComponentAssignLevel4With:projectCode
    componentCode1:componentCode1
    componentCode2:componentCode2
    componentCode3:componentCode3
    activityCode:activityCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var projectCode = projectCode_example; // {{String}} 
var componentCode1 = componentCode1_example; // {{String}} 
var componentCode2 = componentCode2_example; // {{String}} 
var componentCode3 = componentCode3_example; // {{String}} 
var activityCode = activityCode_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.projectComponentAssignLevel4(projectCode, componentCode1, componentCode2, componentCode3, activityCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var projectCode = projectCode_example;  // String | 
            var componentCode1 = componentCode1_example;  // String | 
            var componentCode2 = componentCode2_example;  // String | 
            var componentCode3 = componentCode3_example;  // String | 
            var activityCode = activityCode_example;  // String | 

            try
            {
                // Assign to the project the specified components & activity
                apiInstance.projectComponentAssignLevel4(projectCode, componentCode1, componentCode2, componentCode3, activityCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectComponentAssignLevel4: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$projectCode = projectCode_example; // String | 
$componentCode1 = componentCode1_example; // String | 
$componentCode2 = componentCode2_example; // String | 
$componentCode3 = componentCode3_example; // String | 
$activityCode = activityCode_example; // String | 

try {
    $api_instance->projectComponentAssignLevel4($projectCode, $componentCode1, $componentCode2, $componentCode3, $activityCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectComponentAssignLevel4: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $projectCode = projectCode_example; # String | 
my $componentCode1 = componentCode1_example; # String | 
my $componentCode2 = componentCode2_example; # String | 
my $componentCode3 = componentCode3_example; # String | 
my $activityCode = activityCode_example; # String | 

eval { 
    $api_instance->projectComponentAssignLevel4(projectCode => $projectCode, componentCode1 => $componentCode1, componentCode2 => $componentCode2, componentCode3 => $componentCode3, activityCode => $activityCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectComponentAssignLevel4: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
projectCode = projectCode_example # String | 
componentCode1 = componentCode1_example # String | 
componentCode2 = componentCode2_example # String | 
componentCode3 = componentCode3_example # String | 
activityCode = activityCode_example # String | 

try: 
    # Assign to the project the specified components & activity
    api_instance.project_component_assign_level4(projectCode, componentCode1, componentCode2, componentCode3, activityCode)
except ApiException as e:
    print("Exception when calling ProjectApi->projectComponentAssignLevel4: %s\n" % e)

Parameters

Path parameters
Name Description
projectCode*
String
Required
componentCode1*
String
Required
componentCode2*
String
Required
componentCode3*
String
Required
activityCode*
String
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

projectCreate

Add a new project


/project

Usage and SDK Samples

curl -X PUT -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        Project body = ; // Project | 
        try {
            apiInstance.projectCreate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        Project body = ; // Project | 
        try {
            apiInstance.projectCreate(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Project *body = ; // 

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

// Add a new project
[apiInstance projectCreateWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var body = ; // {{Project}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.projectCreate(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var body = new Project(); // Project | 

            try
            {
                // Add a new project
                apiInstance.projectCreate(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$body = ; // Project | 

try {
    $api_instance->projectCreate($body);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectCreate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

eval { 
    $api_instance->projectCreate(body => $body);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectCreate: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Add a new project
    api_instance.project_create(body)
except ApiException as e:
    print("Exception when calling ProjectApi->projectCreate: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 9000 Internal Server error • 90003 Missing project license • 90000 User has no permission to run API • 90001 Invalid parameters

projectDelete

Delete the project with all links by project code. Any project bookings attached to the hierarchy(activity) will be REMOVED


/project/{projectCode}

Usage and SDK Samples

curl -X DELETE -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project/{projectCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | The code of project to delete.
        try {
            apiInstance.projectDelete(projectCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String projectCode = projectCode_example; // String | The code of project to delete.
        try {
            apiInstance.projectDelete(projectCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *projectCode = projectCode_example; // The code of project to delete.

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

// Delete the project with all links by project code. Any project bookings attached to the hierarchy(activity) will be REMOVED
[apiInstance projectDeleteWith:projectCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var projectCode = projectCode_example; // {{String}} The code of project to delete.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.projectDelete(projectCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var projectCode = projectCode_example;  // String | The code of project to delete.

            try
            {
                // Delete the project with all links by project code. Any project bookings attached to the hierarchy(activity) will be REMOVED
                apiInstance.projectDelete(projectCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$projectCode = projectCode_example; // String | The code of project to delete.

try {
    $api_instance->projectDelete($projectCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $projectCode = projectCode_example; # String | The code of project to delete.

eval { 
    $api_instance->projectDelete(projectCode => $projectCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectDelete: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
projectCode = projectCode_example # String | The code of project to delete.

try: 
    # Delete the project with all links by project code. Any project bookings attached to the hierarchy(activity) will be REMOVED
    api_instance.project_delete(projectCode)
except ApiException as e:
    print("Exception when calling ProjectApi->projectDelete: %s\n" % e)

Parameters

Path parameters
Name Description
projectCode*
String
The code of project to delete.
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

projectEntityUpdate

Patch the project link. Actions can be one of reactivate the link, inactivate or unlink(remove) the hierarchy


/project/entity/{code}/operation/{operation}

Usage and SDK Samples

curl -X PATCH -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project/entity/{code}/operation/{operation}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String entityCode = entityCode_example; // String | The code of the project entity to update.
        String operation = operation_example; // String | The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)
        try {
            apiInstance.projectEntityUpdate(entityCode, operation);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectEntityUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String entityCode = entityCode_example; // String | The code of the project entity to update.
        String operation = operation_example; // String | The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)
        try {
            apiInstance.projectEntityUpdate(entityCode, operation);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectEntityUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *entityCode = entityCode_example; // The code of the project entity to update.
String *operation = operation_example; // The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)

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

// Patch the project link. Actions can be one of reactivate the link, inactivate or unlink(remove) the hierarchy
[apiInstance projectEntityUpdateWith:entityCode
    operation:operation
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var entityCode = entityCode_example; // {{String}} The code of the project entity to update.
var operation = operation_example; // {{String}} The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.projectEntityUpdate(entityCode, operation, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var entityCode = entityCode_example;  // String | The code of the project entity to update.
            var operation = operation_example;  // String | The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)

            try
            {
                // Patch the project link. Actions can be one of reactivate the link, inactivate or unlink(remove) the hierarchy
                apiInstance.projectEntityUpdate(entityCode, operation);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectEntityUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$entityCode = entityCode_example; // String | The code of the project entity to update.
$operation = operation_example; // String | The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)

try {
    $api_instance->projectEntityUpdate($entityCode, $operation);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectEntityUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $entityCode = entityCode_example; # String | The code of the project entity to update.
my $operation = operation_example; # String | The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)

eval { 
    $api_instance->projectEntityUpdate(entityCode => $entityCode, operation => $operation);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectEntityUpdate: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
entityCode = entityCode_example # String | The code of the project entity to update.
operation = operation_example # String | The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)

try: 
    # Patch the project link. Actions can be one of reactivate the link, inactivate or unlink(remove) the hierarchy
    api_instance.project_entity_update(entityCode, operation)
except ApiException as e:
    print("Exception when calling ProjectApi->projectEntityUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
entityCode*
String
The code of the project entity to update.
Required
operation*
String
The operation type to do. Possible values are ACTIVATE or DEACTIVATE or UNLINKSOFT(if there are project bookings attached, the project link is not removed) or UNLINKHARD (remove attached project bookings)
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

projectGet

Get Project tree from Astrow


/project

Usage and SDK Samples

curl -X GET -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        String startDate = startDate_example; // String | Start date of project in YYYY-mm-dd format
        String endDate = endDate_example; // String | End date of project in YYYY-mm-dd format
        try {
            array[ProjectHierarchy] result = apiInstance.projectGet(startDate, endDate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        String startDate = startDate_example; // String | Start date of project in YYYY-mm-dd format
        String endDate = endDate_example; // String | End date of project in YYYY-mm-dd format
        try {
            array[ProjectHierarchy] result = apiInstance.projectGet(startDate, endDate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
String *startDate = startDate_example; // Start date of project in YYYY-mm-dd format
String *endDate = endDate_example; // End date of project in YYYY-mm-dd format

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

// Get Project tree from Astrow
[apiInstance projectGetWith:startDate
    endDate:endDate
              completionHandler: ^(array[ProjectHierarchy] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var startDate = startDate_example; // {{String}} Start date of project in YYYY-mm-dd format
var endDate = endDate_example; // {{String}} End date of project in YYYY-mm-dd format

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.projectGet(startDate, endDate, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var startDate = startDate_example;  // String | Start date of project in YYYY-mm-dd format
            var endDate = endDate_example;  // String | End date of project in YYYY-mm-dd format

            try
            {
                // Get Project tree from Astrow
                array[ProjectHierarchy] result = apiInstance.projectGet(startDate, endDate);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$startDate = startDate_example; // String | Start date of project in YYYY-mm-dd format
$endDate = endDate_example; // String | End date of project in YYYY-mm-dd format

try {
    $result = $api_instance->projectGet($startDate, $endDate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $startDate = startDate_example; # String | Start date of project in YYYY-mm-dd format
my $endDate = endDate_example; # String | End date of project in YYYY-mm-dd format

eval { 
    my $result = $api_instance->projectGet(startDate => $startDate, endDate => $endDate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectGet: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
startDate = startDate_example # String | Start date of project in YYYY-mm-dd format
endDate = endDate_example # String | End date of project in YYYY-mm-dd format

try: 
    # Get Project tree from Astrow
    api_response = api_instance.project_get(startDate, endDate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProjectApi->projectGet: %s\n" % e)

Parameters

Header parameters
Name Description
startDate*
String
Start date of project in YYYY-mm-dd format
Required
endDate*
String
End date of project in YYYY-mm-dd format
Required

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error

projectUpdate

Patch the project by changing the definition


/project/{projectCode}

Usage and SDK Samples

curl -X PATCH -H "Authorization: Basic [[basicHash]]" "https://astrow.net/AstrowIntegrationWebService/v1/project/{projectCode}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProjectApi;

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

public class ProjectApiExample {

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

        ProjectApi apiInstance = new ProjectApi();
        Project body = ; // Project | 
        String projectCode = projectCode_example; // String | The code of the project to update.
        try {
            apiInstance.projectUpdate(body, projectCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProjectApi;

public class ProjectApiExample {

    public static void main(String[] args) {
        ProjectApi apiInstance = new ProjectApi();
        Project body = ; // Project | 
        String projectCode = projectCode_example; // String | The code of the project to update.
        try {
            apiInstance.projectUpdate(body, projectCode);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProjectApi#projectUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: basicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
Project *body = ; // 
String *projectCode = projectCode_example; // The code of the project to update.

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

// Patch the project by changing the definition
[apiInstance projectUpdateWith:body
    projectCode:projectCode
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var AstrowCloudRestApi = require('astrow_cloud_rest_api');
var defaultClient = AstrowCloudRestApi.ApiClient.instance;
// Configure HTTP basic authorization: basicAuth
var basicAuth = defaultClient.authentications['basicAuth'];
basicAuth.username = 'YOUR USERNAME'
basicAuth.password = 'YOUR PASSWORD'

var api = new AstrowCloudRestApi.ProjectApi()
var body = ; // {{Project}} 
var projectCode = projectCode_example; // {{String}} The code of the project to update.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.projectUpdate(bodyprojectCode, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            var apiInstance = new ProjectApi();
            var body = new Project(); // Project | 
            var projectCode = projectCode_example;  // String | The code of the project to update.

            try
            {
                // Patch the project by changing the definition
                apiInstance.projectUpdate(body, projectCode);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProjectApi.projectUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: basicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiProjectApi();
$body = ; // Project | 
$projectCode = projectCode_example; // String | The code of the project to update.

try {
    $api_instance->projectUpdate($body, $projectCode);
} catch (Exception $e) {
    echo 'Exception when calling ProjectApi->projectUpdate: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProjectApi;
# Configure HTTP basic authorization: basicAuth
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ProjectApi->new();
my $body = WWW::SwaggerClient::Object::Project->new(); # Project | 
my $projectCode = projectCode_example; # String | The code of the project to update.

eval { 
    $api_instance->projectUpdate(body => $body, projectCode => $projectCode);
};
if ($@) {
    warn "Exception when calling ProjectApi->projectUpdate: $@\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: basicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ProjectApi()
body =  # Project | 
projectCode = projectCode_example # String | The code of the project to update.

try: 
    # Patch the project by changing the definition
    api_instance.project_update(body, projectCode)
except ApiException as e:
    print("Exception when calling ProjectApi->projectUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
projectCode*
String
The code of the project to update.
Required
Body parameters
Name Description
body *

Responses

Status: 200

OK

Status: 400

Error codes: • 90000 User has no permission to run API • 9000 Internal Server error