Foundry API

SearchMachineStatusesRequest

The following routes are available for this service:
GET	/machines/{Id}/statuses

import 'package:servicestack/servicestack.dart';

abstract class GetOperationUnTenanted<TResponse> implements IHasGetOptions, IGet
{
    String? embed;

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

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

    Map<String, dynamic> toJson() => {
        'embed': embed
    };

    getTypeName() => "GetOperationUnTenanted<$TResponse>";
    TypeContext? context = _ctx;
}

abstract class SearchOperationUnTenanted<TResponse> extends GetOperationUnTenanted<TResponse> implements IHasSearchOptions
{
    String? distinct;
    int? limit;
    int? offset;
    String? sort;
    String? filter;

    SearchOperationUnTenanted({this.distinct,this.limit,this.offset,this.sort,this.filter});
    SearchOperationUnTenanted.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        distinct = json['distinct'];
        limit = json['limit'];
        offset = json['offset'];
        sort = json['sort'];
        filter = json['filter'];
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'distinct': distinct,
        'limit': limit,
        'offset': offset,
        'sort': sort,
        'filter': filter
    });

    getTypeName() => "SearchOperationUnTenanted<$TResponse>";
    TypeContext? context = _ctx;
}

abstract class SearchOperationTenanted<TResponse> extends SearchOperationUnTenanted<TResponse> implements ITenantedRequest
{
    String? organisationId;

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

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

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

    getTypeName() => "SearchOperationTenanted<$TResponse>";
    TypeContext? context = _ctx;
}

enum SortDirection
{
    Ascending,
    Descending,
}

class Sorting implements IConvertible
{
    String? by;
    SortDirection? direction;

    Sorting({this.by,this.direction});
    Sorting.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'by': by,
        'direction': JsonConverters.toJson(direction,'SortDirection',context!)
    };

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

class Filtering implements IConvertible
{
    List<String>? fields;

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

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

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

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

class SearchMetadata implements IConvertible
{
    int? total;
    int? limit;
    int? offset;
    Sorting? sort;
    Filtering? filter;

    SearchMetadata({this.total,this.limit,this.offset,this.sort,this.filter});
    SearchMetadata.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        total = json['total'];
        limit = json['limit'];
        offset = json['offset'];
        sort = JsonConverters.fromJson(json['sort'],'Sorting',context!);
        filter = JsonConverters.fromJson(json['filter'],'Filtering',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'total': total,
        'limit': limit,
        'offset': offset,
        'sort': JsonConverters.toJson(sort,'Sorting',context!),
        'filter': JsonConverters.toJson(filter,'Filtering',context!)
    };

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

abstract class SearchOperationResponse
{
    SearchMetadata? metadata;

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

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

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

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

class MachineStatus implements IConvertible
{
    String? component;
    DateTime? observedAt;
    String? code;
    String? errorCode;
    String? errorDetails;

    MachineStatus({this.component,this.observedAt,this.code,this.errorCode,this.errorDetails});
    MachineStatus.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        component = json['component'];
        observedAt = JsonConverters.fromJson(json['observedAt'],'DateTime',context!);
        code = json['code'];
        errorCode = json['errorCode'];
        errorDetails = json['errorDetails'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'component': component,
        'observedAt': JsonConverters.toJson(observedAt,'DateTime',context!),
        'code': code,
        'errorCode': errorCode,
        'errorDetails': errorDetails
    };

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

class SearchMachineStatusesResponse extends SearchOperationResponse implements IConvertible
{
    List<MachineStatus>? statuses;
    ResponseStatus? responseStatus;

    SearchMachineStatusesResponse({this.statuses,this.responseStatus});
    SearchMachineStatusesResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        statuses = JsonConverters.fromJson(json['statuses'],'List<MachineStatus>',context!);
        responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'statuses': JsonConverters.toJson(statuses,'List<MachineStatus>',context!),
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
    });

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

class SearchMachineStatusesRequest extends SearchOperationTenanted<SearchMachineStatusesResponse> implements IConvertible
{
    String? id;
    List<String>? targetComponents;
    DateTime? observedAfter;
    DateTime? observedBefore;

    SearchMachineStatusesRequest({this.id,this.targetComponents,this.observedAfter,this.observedBefore});
    SearchMachineStatusesRequest.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        super.fromMap(json);
        id = json['id'];
        targetComponents = JsonConverters.fromJson(json['targetComponents'],'List<String>',context!);
        observedAfter = JsonConverters.fromJson(json['observedAfter'],'DateTime',context!);
        observedBefore = JsonConverters.fromJson(json['observedBefore'],'DateTime',context!);
        return this;
    }

    Map<String, dynamic> toJson() => super.toJson()..addAll({
        'id': id,
        'targetComponents': JsonConverters.toJson(targetComponents,'List<String>',context!),
        'observedAfter': JsonConverters.toJson(observedAfter,'DateTime',context!),
        'observedBefore': JsonConverters.toJson(observedBefore,'DateTime',context!)
    });

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

TypeContext _ctx = TypeContext(library: 'foundrystage_api_app.azurewebsites.net', types: <String, TypeInfo> {
    'GetOperationUnTenanted<TResponse>': TypeInfo(TypeOf.AbstractClass),
    'SearchOperationUnTenanted<TResponse>': TypeInfo(TypeOf.AbstractClass),
    'SearchOperationTenanted<TResponse>': TypeInfo(TypeOf.AbstractClass),
    'SortDirection': TypeInfo(TypeOf.Enum, enumValues:SortDirection.values),
    'Sorting': TypeInfo(TypeOf.Class, create:() => Sorting()),
    'Filtering': TypeInfo(TypeOf.Class, create:() => Filtering()),
    'SearchMetadata': TypeInfo(TypeOf.Class, create:() => SearchMetadata()),
    'SearchOperationResponse': TypeInfo(TypeOf.AbstractClass),
    'MachineStatus': TypeInfo(TypeOf.Class, create:() => MachineStatus()),
    'SearchMachineStatusesResponse': TypeInfo(TypeOf.Class, create:() => SearchMachineStatusesResponse()),
    'List<MachineStatus>': TypeInfo(TypeOf.Class, create:() => <MachineStatus>[]),
    'SearchMachineStatusesRequest': TypeInfo(TypeOf.Class, create:() => SearchMachineStatusesRequest()),
});

Dart SearchMachineStatusesRequest DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .xml suffix or ?format=xml

HTTP + XML

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

GET /machines/{Id}/statuses HTTP/1.1 
Host: foundrystage-api-app.azurewebsites.net 
Accept: application/xml

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

<SearchMachineStatusesResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Infrastructure.Api.Interfaces.ServiceOperations.Machines">
  <Metadata xmlns:d2p1="http://schemas.datacontract.org/2004/07/Application.Interfaces" xmlns="http://schemas.datacontract.org/2004/07/Infrastructure.Api.Interfaces.ServiceOperations">
    <d2p1:Filter>
      <d2p1:Fields xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:string>String</d4p1:string>
      </d2p1:Fields>
    </d2p1:Filter>
    <d2p1:Limit>0</d2p1:Limit>
    <d2p1:Offset>0</d2p1:Offset>
    <d2p1:Sort>
      <d2p1:By>String</d2p1:By>
      <d2p1:Direction>Ascending</d2p1:Direction>
    </d2p1:Sort>
    <d2p1:Total>0</d2p1:Total>
  </Metadata>
  <ResponseStatus xmlns:d2p1="http://schemas.servicestack.net/types">
    <d2p1:ErrorCode>String</d2p1:ErrorCode>
    <d2p1:Message>String</d2p1:Message>
    <d2p1:StackTrace>String</d2p1:StackTrace>
    <d2p1:Errors>
      <d2p1:ResponseError>
        <d2p1:ErrorCode>String</d2p1:ErrorCode>
        <d2p1:FieldName>String</d2p1:FieldName>
        <d2p1:Message>String</d2p1:Message>
        <d2p1:Meta xmlns:d5p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
          <d5p1:KeyValueOfstringstring>
            <d5p1:Key>String</d5p1:Key>
            <d5p1:Value>String</d5p1:Value>
          </d5p1:KeyValueOfstringstring>
        </d2p1:Meta>
      </d2p1:ResponseError>
    </d2p1:Errors>
    <d2p1:Meta xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
      <d3p1:KeyValueOfstringstring>
        <d3p1:Key>String</d3p1:Key>
        <d3p1:Value>String</d3p1:Value>
      </d3p1:KeyValueOfstringstring>
    </d2p1:Meta>
  </ResponseStatus>
  <Statuses xmlns:d2p1="http://schemas.datacontract.org/2004/07/Application.Interfaces.Resources">
    <d2p1:MachineStatus>
      <d2p1:Code>String</d2p1:Code>
      <d2p1:Component>String</d2p1:Component>
      <d2p1:ErrorCode>String</d2p1:ErrorCode>
      <d2p1:ErrorDetails>String</d2p1:ErrorDetails>
      <d2p1:ObservedAt>0001-01-01T00:00:00</d2p1:ObservedAt>
    </d2p1:MachineStatus>
  </Statuses>
</SearchMachineStatusesResponse>