| GET | /api/v1/devices/{Guid} |
|---|
import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';
enum EinheitType
{
L,
Kg,
CBM,
Stck,
KWH,
MWH,
GWH,
T,
RM,
Einheit,
Qm,
GJ,
MJ,
Null,
St,
Srm,
Wh,
}
// @DataContract
class DeviceCatalog implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="TypKurz")
String? TypKurz;
// @DataMember(Name="TypLang")
String? TypLang;
// @DataMember(Name="Ablesbar")
bool? Ablesbar;
// @DataMember(Name="Klasse")
String? Klasse;
// @DataMember(Name="Abzug")
bool? Abzug;
// @DataMember(Name="Hkvv")
bool? Hkvv;
// @DataMember(Name="Funk")
bool? Funk;
DeviceCatalog({this.Guid,this.TypKurz,this.TypLang,this.Ablesbar,this.Klasse,this.Abzug,this.Hkvv,this.Funk});
DeviceCatalog.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
TypKurz = json['typeShort'];
TypLang = json['typeLong'];
Ablesbar = json['readable'];
Klasse = json['class'];
Abzug = json['subtraction'];
Hkvv = json['hkvv'];
Funk = json['radio'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'typKurz': TypKurz,
'typLang': TypLang,
'ablesbar': Ablesbar,
'klasse': Klasse,
'abzug': Abzug,
'hkvv': Hkvv,
'funk': Funk
};
getTypeName() => "DeviceCatalog";
TypeContext? context = _ctx;
}
enum DeviceReadingKind
{
ZA,
HA,
MO,
EB,
AB,
}
// @DataContract
class DeviceConsumption implements IConvertible
{
// @DataMember
String? guid;
// @DataMember
double? deviceReading;
// @DataMember
DateTime? deviceReadingDate;
// @DataMember
DeviceReadingKind? deviceReadingKind;
// @DataMember
DateTime? changeDate;
// @DataMember
String? note;
// @DataMember
String? ampouleColour;
// @DataMember
String? deviceGuid;
DeviceConsumption({this.guid,this.deviceReading,this.deviceReadingDate,this.deviceReadingKind,this.changeDate,this.note,this.ampouleColour,this.deviceGuid});
DeviceConsumption.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
guid = json['guid'];
deviceReading = JsonConverters.toDouble(json['deviceReading']);
deviceReadingDate = JsonConverters.fromJson(json['deviceReadingDate'],'DateTime',context!);
deviceReadingKind = JsonConverters.fromJson(json['deviceReadingKind'],'DeviceReadingKind',context!);
changeDate = JsonConverters.fromJson(json['changeDate'],'DateTime',context!);
note = json['note'];
ampouleColour = json['ampouleColour'];
deviceGuid = json['deviceGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': guid,
'deviceReading': deviceReading,
'deviceReadingDate': JsonConverters.toJson(deviceReadingDate,'DateTime',context!),
'deviceReadingKind': JsonConverters.toJson(deviceReadingKind,'DeviceReadingKind',context!),
'changeDate': JsonConverters.toJson(changeDate,'DateTime',context!),
'note': note,
'ampouleColour': ampouleColour,
'deviceGuid': deviceGuid
};
getTypeName() => "DeviceConsumption";
TypeContext? context = _ctx;
}
// @DataContract
class Device implements IConvertible
{
// @DataMember
String? guid;
// @DataMember
String? number;
// @DataMember
String? label;
// @DataMember
String? description;
// @DataMember
DateTime? installationDate;
// @DataMember
DateTime? deinstallationDate;
// @DataMember
DateTime? calibrationDate;
// @DataMember
EinheitType? unit;
// @DataMember
String? note;
// @DataMember
DeviceCatalog? deviceCatalog;
// @DataMember
List<DeviceConsumption>? deviceConsumptions;
Device({this.guid,this.number,this.label,this.description,this.installationDate,this.deinstallationDate,this.calibrationDate,this.unit,this.note,this.deviceCatalog,this.deviceConsumptions});
Device.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
guid = json['guid'];
number = json['number'];
label = json['label'];
description = json['description'];
installationDate = JsonConverters.fromJson(json['installationDate'],'DateTime',context!);
deinstallationDate = JsonConverters.fromJson(json['deinstallationDate'],'DateTime',context!);
calibrationDate = JsonConverters.fromJson(json['calibrationDate'],'DateTime',context!);
unit = JsonConverters.fromJson(json['unit'],'EinheitType',context!);
note = json['note'];
deviceCatalog = JsonConverters.fromJson(json['deviceCatalog'],'DeviceCatalog',context!);
deviceConsumptions = JsonConverters.fromJson(json['deviceConsumptions'],'List<DeviceConsumption>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': guid,
'number': number,
'label': label,
'description': description,
'installationDate': JsonConverters.toJson(installationDate,'DateTime',context!),
'deinstallationDate': JsonConverters.toJson(deinstallationDate,'DateTime',context!),
'calibrationDate': JsonConverters.toJson(calibrationDate,'DateTime',context!),
'unit': JsonConverters.toJson(unit,'EinheitType',context!),
'note': note,
'deviceCatalog': JsonConverters.toJson(deviceCatalog,'DeviceCatalog',context!),
'deviceConsumptions': JsonConverters.toJson(deviceConsumptions,'List<DeviceConsumption>',context!)
};
getTypeName() => "Device";
TypeContext? context = _ctx;
}
class GetDeviceResponse implements IConvertible
{
Device? device;
ResponseStatus? responseStatus;
GetDeviceResponse({this.device,this.responseStatus});
GetDeviceResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
device = JsonConverters.fromJson(json['device'],'Device',context!);
responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
return this;
}
Map<String, dynamic> toJson() => {
'device': JsonConverters.toJson(device,'Device',context!),
'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
};
getTypeName() => "GetDeviceResponse";
TypeContext? context = _ctx;
}
class GetDevice implements IHasBearerToken, IConvertible
{
// @ApiMember(IsRequired=true, ParameterType="query")
String? bearerToken;
// @ApiMember(IsRequired=true, ParameterType="path")
String? guid;
GetDevice({this.bearerToken,this.guid});
GetDevice.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
bearerToken = json['bearerToken'];
guid = json['guid'];
return this;
}
Map<String, dynamic> toJson() => {
'bearerToken': bearerToken,
'guid': guid
};
getTypeName() => "GetDevice";
TypeContext? context = _ctx;
}
TypeContext _ctx = TypeContext(library: 'develop_servdesk.eras_online.de', types: <String, TypeInfo> {
'EinheitType': TypeInfo(TypeOf.Enum, enumValues:EinheitType.values),
'DeviceCatalog': TypeInfo(TypeOf.Class, create:() => DeviceCatalog()),
'DeviceReadingKind': TypeInfo(TypeOf.Enum, enumValues:DeviceReadingKind.values),
'DeviceConsumption': TypeInfo(TypeOf.Class, create:() => DeviceConsumption()),
'Device': TypeInfo(TypeOf.Class, create:() => Device()),
'List<DeviceConsumption>': TypeInfo(TypeOf.Class, create:() => <DeviceConsumption>[]),
'GetDeviceResponse': TypeInfo(TypeOf.Class, create:() => GetDeviceResponse()),
'GetDevice': TypeInfo(TypeOf.Class, create:() => GetDevice()),
});
To override the Content-type in your clients, use the HTTP Accept Header, append the .jsv suffix or ?format=jsv
The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.
GET /api/v1/devices/{Guid} HTTP/1.1
Host: develop-servdesk.eras-online.de
Accept: text/jsv
HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length
{
device:
{
guid: 00000000000000000000000000000000,
number: String,
label: String,
description: String,
installationDate: 0001-01-01T00:00:00Z,
deinstallationDate: 0001-01-01T00:00:00Z,
calibrationDate: 0001-01-01T00:00:00Z,
unit: L,
note: String,
deviceCatalog:
{
Guid: String,
TypKurz: String,
TypLang: String,
Ablesbar: False,
Klasse: String,
Abzug: False,
Hkvv: False,
Funk: False
},
deviceConsumptions:
[
{
guid: 00000000000000000000000000000000,
deviceReading: 0,
deviceReadingDate: 0001-01-01T00:00:00Z,
deviceReadingKind: ZA,
changeDate: 0001-01-01T00:00:00Z,
note: String,
ampouleColour: String,
deviceGuid: String
}
]
},
responseStatus:
{
errorCode: String,
message: String,
stackTrace: String,
errors:
[
{
errorCode: String,
fieldName: String,
message: String,
meta:
{
String: String
}
}
],
meta:
{
String: String
}
}
}