DX STF Client API

<back to all web services

SearchSenderInvoice

Invoice

import 'package:servicestack/servicestack.dart';

enum ORDER
{
    ASC,
    DESC,
}

class SearchInvoiceByDateFilter implements ISearchInvoiceByDateFilter, IConvertible
{
    DateTime fromDate = DateTime(0);
    DateTime toDate = DateTime(0);
    String continuationToken = "";
    int requestedPage = 0;
    int numberOfRecordsPerPage = 0;
    String orderBy = "";
    ORDER order;

    SearchInvoiceByDateFilter({this.fromDate,this.toDate,this.continuationToken,this.requestedPage,this.numberOfRecordsPerPage,this.orderBy,this.order});
    SearchInvoiceByDateFilter.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        fromDate = JsonConverters.fromJson(json['fromDate'],'DateTime',context!);
        toDate = JsonConverters.fromJson(json['toDate'],'DateTime',context!);
        continuationToken = json['continuationToken'];
        requestedPage = json['requestedPage'];
        numberOfRecordsPerPage = json['numberOfRecordsPerPage'];
        orderBy = json['orderBy'];
        order = JsonConverters.fromJson(json['order'],'ORDER',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'fromDate': JsonConverters.toJson(fromDate,'DateTime',context!),
        'toDate': JsonConverters.toJson(toDate,'DateTime',context!),
        'continuationToken': continuationToken,
        'requestedPage': requestedPage,
        'numberOfRecordsPerPage': numberOfRecordsPerPage,
        'orderBy': orderBy,
        'order': JsonConverters.toJson(order,'ORDER',context!)
    };

    getTypeName() => "SearchInvoiceByDateFilter";
    TypeContext? context = _ctx;
}

/**
* Invoice
*/
// @Api(Description="Invoice")
// @ApiResponse(Description="Paged Purchase data", IsDefaultResponse=true, ResponseType=typeof(0, Culture=neutral, PublicKeyToken=null]]), StatusCode=200)
class SearchSenderInvoice implements IConvertible
{
    /**
    * Search query
    */
    // @ApiMember(Description="Search query", ParameterType="model")
    SearchInvoiceByDateFilter query;

    SearchSenderInvoice({this.query});
    SearchSenderInvoice.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        query = JsonConverters.fromJson(json['query'],'SearchInvoiceByDateFilter',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'query': JsonConverters.toJson(query,'SearchInvoiceByDateFilter',context!)
    };

    getTypeName() => "SearchSenderInvoice";
    TypeContext? context = _ctx;
}

class PagedQueryResult<T> implements IConvertible
{
    int startIndex = 0;
    int endIndex = 0;
    int numberOfRecordsReturned = 0;
    int totalNumberOfPages = 0;
    int totalNumberOfRecords = 0;
    List<ResultItem<ClaimMessage>> results = [];

    PagedQueryResult({this.startIndex,this.endIndex,this.numberOfRecordsReturned,this.totalNumberOfPages,this.totalNumberOfRecords,this.results});
    PagedQueryResult.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        startIndex = json['startIndex'];
        endIndex = json['endIndex'];
        numberOfRecordsReturned = json['numberOfRecordsReturned'];
        totalNumberOfPages = json['totalNumberOfPages'];
        totalNumberOfRecords = json['totalNumberOfRecords'];
        results = JsonConverters.fromJson(json['results'],'List<ResultItem<ClaimMessage>>',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'startIndex': startIndex,
        'endIndex': endIndex,
        'numberOfRecordsReturned': numberOfRecordsReturned,
        'totalNumberOfPages': totalNumberOfPages,
        'totalNumberOfRecords': totalNumberOfRecords,
        'results': JsonConverters.toJson(results,'List<ResultItem<ClaimMessage>>',context!)
    };

    getTypeName() => "PagedQueryResult<$T>";
    TypeContext? context = _ctx;
}

class PagedQueryResponseWithToken<T> extends PagedQueryResult<ResultItem<InvoiceMessage>> implements IConvertible
{
    String continuationToken = "";

    PagedQueryResponseWithToken({this.continuationToken});
    PagedQueryResponseWithToken.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        continuationToken = json['continuationToken'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'continuationToken': continuationToken
    });

    getTypeName() => "PagedQueryResponseWithToken<$T>";
    TypeContext? context = _ctx;
}

TypeContext _ctx = TypeContext(library: 'stf_api_uat.data_xchange.co.za', types: <String, TypeInfo> {
    'ORDER': TypeInfo(TypeOf.Enum, enumValues:ORDER.values),
    'SearchInvoiceByDateFilter': TypeInfo(TypeOf.Class, create:() => SearchInvoiceByDateFilter()),
    'SearchSenderInvoice': TypeInfo(TypeOf.Class, create:() => SearchSenderInvoice()),
    'PagedQueryResult<T>': TypeInfo(TypeOf.Class, create:() => PagedQueryResult<T>()),
    'List<ResultItem<ClaimMessage>>': TypeInfo(TypeOf.Class, create:() => <ResultItem<ClaimMessage>>[]),
    'ResultItem<ClaimMessage>': TypeInfo(TypeOf.Class, create:() => ResultItem<ClaimMessage>()),
    'ClaimMessage': TypeInfo(TypeOf.Class, create:() => ClaimMessage()),
    'PagedQueryResponseWithToken<T>': TypeInfo(TypeOf.Class, create:() => PagedQueryResponseWithToken<T>()),
});

Dart SearchSenderInvoice DTOs

POST /api/invoice/search/sender HTTP/1.1 
Host: stf-api-uat.data-xchange.co.za 
Accept: application/json
Content-Type: application/json
Content-Length: length

{"query":{"continuationToken":"String","requestedPage":0,"numberOfRecordsPerPage":0,"orderBy":"String","order":"ASC"}}

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: length

{"continuationToken":"String","startIndex":0,"endIndex":0,"numberOfRecordsReturned":0,"totalNumberOfPages":0,"totalNumberOfRecords":0,"results":[{}]}