Trackunit API

GetAlarm

The following routes are available for this service:
GET POST	/GetAlarm
GET POST	/GetAlarm/{Id}
GET	/Alarm
GET	/Alarm/{Id}

import 'package:servicestack/servicestack.dart';

// @DataContract
class TemperatureAlarmLimits implements IConvertible
{
    // @DataMember
    double? temperature1LowerLimit;

    // @DataMember
    double? temperature1UpperLimit;

    // @DataMember
    double? temperature2LowerLimit;

    // @DataMember
    double? temperature2UpperLimit;

    TemperatureAlarmLimits({this.temperature1LowerLimit,this.temperature1UpperLimit,this.temperature2LowerLimit,this.temperature2UpperLimit});
    TemperatureAlarmLimits.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        temperature1LowerLimit = JsonConverters.toDouble(json['temperature1LowerLimit']);
        temperature1UpperLimit = JsonConverters.toDouble(json['temperature1UpperLimit']);
        temperature2LowerLimit = JsonConverters.toDouble(json['temperature2LowerLimit']);
        temperature2UpperLimit = JsonConverters.toDouble(json['temperature2UpperLimit']);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'temperature1LowerLimit': temperature1LowerLimit,
        'temperature1UpperLimit': temperature1UpperLimit,
        'temperature2LowerLimit': temperature2LowerLimit,
        'temperature2UpperLimit': temperature2UpperLimit
    };

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

// @DataContract
class ADVoltageAlarmLimits implements IConvertible
{
    // @DataMember
    double? adVoltageLowerLimit;

    // @DataMember
    double? adVoltageUpperLimit;

    ADVoltageAlarmLimits({this.adVoltageLowerLimit,this.adVoltageUpperLimit});
    ADVoltageAlarmLimits.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        adVoltageLowerLimit = JsonConverters.toDouble(json['adVoltageLowerLimit']);
        adVoltageUpperLimit = JsonConverters.toDouble(json['adVoltageUpperLimit']);
        return this;
    }

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

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

// @DataContract
class Location implements IConvertible
{
    // @DataMember
    double? latitude;

    // @DataMember
    double? longitude;

    Location({this.latitude,this.longitude});
    Location.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        latitude = JsonConverters.toDouble(json['latitude']);
        longitude = JsonConverters.toDouble(json['longitude']);
        return this;
    }

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

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

// @DataContract
class TimeOfDay implements IConvertible
{
    // @DataMember
    int? hour;

    // @DataMember
    int? minute;

    TimeOfDay({this.hour,this.minute});
    TimeOfDay.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

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

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

// @DataContract
class Alarm implements IConvertible
{
    // @DataMember
    String? id;

    // @DataMember
    DateTime? created;

    // @DataMember
    String? name;

    // @DataMember
    String? type;

    // @DataMember
    bool? enabled;

    // @DataMember
    bool? allUnits;

    // @DataMember
    List<String>? units;

    // @DataMember
    List<String>? groups;

    // @DataMember
    List<String>? emailRecipients;

    // @DataMember
    List<String>? systemRecipients;

    // @DataMember
    List<String>? smsRecipients;

    // @DataMember
    TemperatureAlarmLimits? temperatureLimits;

    // @DataMember
    ADVoltageAlarmLimits? adVoltageLimits;

    // @DataMember
    int? adVoltageInputIndex;

    // @DataMember
    double? threshold;

    // @DataMember
    double? batteryLevel;

    // @DataMember
    Location? location;

    // @DataMember
    double? radius;

    // @DataMember
    int? inputIndex;

    // @DataMember
    double? interval;

    // @DataMember
    String? pointId;

    // @DataMember
    DateTime? expectedArrivalTime;

    // @DataMember
    double? powerLevel;

    // @DataMember
    List<String>? weekdays;

    // @DataMember
    TimeOfDay? timeStart;

    // @DataMember
    TimeOfDay? timeEnd;

    // @DataMember
    String? zoneId;

    Alarm({this.id,this.created,this.name,this.type,this.enabled,this.allUnits,this.units,this.groups,this.emailRecipients,this.systemRecipients,this.smsRecipients,this.temperatureLimits,this.adVoltageLimits,this.adVoltageInputIndex,this.threshold,this.batteryLevel,this.location,this.radius,this.inputIndex,this.interval,this.pointId,this.expectedArrivalTime,this.powerLevel,this.weekdays,this.timeStart,this.timeEnd,this.zoneId});
    Alarm.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        id = json['id'];
        created = JsonConverters.fromJson(json['created'],'DateTime',context!);
        name = json['name'];
        type = json['type'];
        enabled = json['enabled'];
        allUnits = json['allUnits'];
        units = JsonConverters.fromJson(json['units'],'List<String>',context!);
        groups = JsonConverters.fromJson(json['groups'],'List<String>',context!);
        emailRecipients = JsonConverters.fromJson(json['emailRecipients'],'List<String>',context!);
        systemRecipients = JsonConverters.fromJson(json['systemRecipients'],'List<String>',context!);
        smsRecipients = JsonConverters.fromJson(json['smsRecipients'],'List<String>',context!);
        temperatureLimits = JsonConverters.fromJson(json['temperatureLimits'],'TemperatureAlarmLimits',context!);
        adVoltageLimits = JsonConverters.fromJson(json['adVoltageLimits'],'ADVoltageAlarmLimits',context!);
        adVoltageInputIndex = json['adVoltageInputIndex'];
        threshold = JsonConverters.toDouble(json['threshold']);
        batteryLevel = JsonConverters.toDouble(json['batteryLevel']);
        location = JsonConverters.fromJson(json['location'],'Location',context!);
        radius = JsonConverters.toDouble(json['radius']);
        inputIndex = json['inputIndex'];
        interval = JsonConverters.toDouble(json['interval']);
        pointId = json['pointId'];
        expectedArrivalTime = JsonConverters.fromJson(json['expectedArrivalTime'],'DateTime',context!);
        powerLevel = JsonConverters.toDouble(json['powerLevel']);
        weekdays = JsonConverters.fromJson(json['weekdays'],'List<String>',context!);
        timeStart = JsonConverters.fromJson(json['timeStart'],'TimeOfDay',context!);
        timeEnd = JsonConverters.fromJson(json['timeEnd'],'TimeOfDay',context!);
        zoneId = json['zoneId'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'id': id,
        'created': JsonConverters.toJson(created,'DateTime',context!),
        'name': name,
        'type': type,
        'enabled': enabled,
        'allUnits': allUnits,
        'units': JsonConverters.toJson(units,'List<String>',context!),
        'groups': JsonConverters.toJson(groups,'List<String>',context!),
        'emailRecipients': JsonConverters.toJson(emailRecipients,'List<String>',context!),
        'systemRecipients': JsonConverters.toJson(systemRecipients,'List<String>',context!),
        'smsRecipients': JsonConverters.toJson(smsRecipients,'List<String>',context!),
        'temperatureLimits': JsonConverters.toJson(temperatureLimits,'TemperatureAlarmLimits',context!),
        'adVoltageLimits': JsonConverters.toJson(adVoltageLimits,'ADVoltageAlarmLimits',context!),
        'adVoltageInputIndex': adVoltageInputIndex,
        'threshold': threshold,
        'batteryLevel': batteryLevel,
        'location': JsonConverters.toJson(location,'Location',context!),
        'radius': radius,
        'inputIndex': inputIndex,
        'interval': interval,
        'pointId': pointId,
        'expectedArrivalTime': JsonConverters.toJson(expectedArrivalTime,'DateTime',context!),
        'powerLevel': powerLevel,
        'weekdays': JsonConverters.toJson(weekdays,'List<String>',context!),
        'timeStart': JsonConverters.toJson(timeStart,'TimeOfDay',context!),
        'timeEnd': JsonConverters.toJson(timeEnd,'TimeOfDay',context!),
        'zoneId': zoneId
    };

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

// @DataContract
class GetAlarmResponse implements IConvertible
{
    // @DataMember
    List<Alarm>? list;

    // @DataMember
    ResponseStatus? responseStatus;

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

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

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

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

// @DataContract
class GetAlarm implements IConvertible
{
    // @DataMember
    String? id;

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

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

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

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

TypeContext _ctx = TypeContext(library: 'api.trackunit.com', types: <String, TypeInfo> {
    'TemperatureAlarmLimits': TypeInfo(TypeOf.Class, create:() => TemperatureAlarmLimits()),
    'ADVoltageAlarmLimits': TypeInfo(TypeOf.Class, create:() => ADVoltageAlarmLimits()),
    'Location': TypeInfo(TypeOf.Class, create:() => Location()),
    'TimeOfDay': TypeInfo(TypeOf.Class, create:() => TimeOfDay()),
    'Alarm': TypeInfo(TypeOf.Class, create:() => Alarm()),
    'GetAlarmResponse': TypeInfo(TypeOf.Class, create:() => GetAlarmResponse()),
    'List<Alarm>': TypeInfo(TypeOf.Class, create:() => <Alarm>[]),
    'GetAlarm': TypeInfo(TypeOf.Class, create:() => GetAlarm()),
});

Dart GetAlarm 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.

POST /GetAlarm HTTP/1.1 
Host: api.trackunit.com 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<GetAlarm xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.servicestack.net/types">
  <Id>String</Id>
</GetAlarm>

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

<GetAlarmResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.servicestack.net/types">
  <List>
    <Alarm>
      <ADVoltageInputIndex>0</ADVoltageInputIndex>
      <ADVoltageLimits>
        <ADVoltageLowerLimit>0</ADVoltageLowerLimit>
        <ADVoltageUpperLimit>0</ADVoltageUpperLimit>
      </ADVoltageLimits>
      <AllUnits>false</AllUnits>
      <BatteryLevel>0</BatteryLevel>
      <Created>0001-01-01T00:00:00</Created>
      <EmailRecipients xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:string>String</d4p1:string>
      </EmailRecipients>
      <Enabled>false</Enabled>
      <ExpectedArrivalTime>0001-01-01T00:00:00</ExpectedArrivalTime>
      <Groups xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:string>String</d4p1:string>
      </Groups>
      <Id>String</Id>
      <InputIndex>0</InputIndex>
      <Interval>0</Interval>
      <Location>
        <Latitude>0</Latitude>
        <Longitude>0</Longitude>
      </Location>
      <Name>String</Name>
      <PointId>String</PointId>
      <PowerLevel>0</PowerLevel>
      <Radius>0</Radius>
      <SmsRecipients xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:string>String</d4p1:string>
      </SmsRecipients>
      <SystemRecipients xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:string>String</d4p1:string>
      </SystemRecipients>
      <TemperatureLimits>
        <Temperature1LowerLimit>0</Temperature1LowerLimit>
        <Temperature1UpperLimit>0</Temperature1UpperLimit>
        <Temperature2LowerLimit>0</Temperature2LowerLimit>
        <Temperature2UpperLimit>0</Temperature2UpperLimit>
      </TemperatureLimits>
      <Threshold>0</Threshold>
      <TimeEnd>
        <Hour>0</Hour>
        <Minute>0</Minute>
      </TimeEnd>
      <TimeStart>
        <Hour>0</Hour>
        <Minute>0</Minute>
      </TimeStart>
      <Type>String</Type>
      <Units xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:string>String</d4p1:string>
      </Units>
      <Weekdays xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:string>String</d4p1:string>
      </Weekdays>
      <ZoneId>String</ZoneId>
    </Alarm>
  </List>
  <ResponseStatus>
    <ErrorCode>String</ErrorCode>
    <Message>String</Message>
    <StackTrace>String</StackTrace>
    <Errors>
      <ResponseError>
        <ErrorCode>String</ErrorCode>
        <FieldName>String</FieldName>
        <Message>String</Message>
        <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>
        </Meta>
      </ResponseError>
    </Errors>
    <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>
    </Meta>
  </ResponseStatus>
</GetAlarmResponse>