| GET | /App/{UserId}/Status/Notes |
|---|
import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';
// @DataContract
abstract class Eras2AppServiceModelBase
{
// @DataMember(Name="UserId")
String? UserId;
Eras2AppServiceModelBase({this.UserId});
Eras2AppServiceModelBase.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
UserId = json['userId'];
return this;
}
Map<String, dynamic> toJson() => {
'userId': UserId
};
getTypeName() => "Eras2AppServiceModelBase";
TypeContext? context = _ctx;
}
// @DataContract
class Address implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="Straße")
String? Stra_e;
// @DataMember(Name="Straße2")
String? Stra_e2;
// @DataMember(Name="Hausnummer")
String? Hausnummer;
// @DataMember(Name="Postleitzahl")
String? Postleitzahl;
// @DataMember(Name="Ort")
String? Ort;
// @DataMember(Name="Postfach")
String? Postfach;
// @DataMember(Name="Adresszusatz")
String? Adresszusatz;
// @DataMember(Name="Breitengrad")
double? Breitengrad;
// @DataMember(Name="Laengengrad")
double? Laengengrad;
Address({this.Guid,this.Stra_e,this.Stra_e2,this.Hausnummer,this.Postleitzahl,this.Ort,this.Postfach,this.Adresszusatz,this.Breitengrad,this.Laengengrad});
Address.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
Stra_e = json['street'];
Stra_e2 = json['street2'];
Hausnummer = json['streetNumber'];
Postleitzahl = json['zipcode'];
Ort = json['city'];
Postfach = json['mailbox'];
Adresszusatz = json['additional'];
Breitengrad = JsonConverters.toDouble(json['latitude']);
Laengengrad = JsonConverters.toDouble(json['longitude']);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'stra_e': Stra_e,
'stra_e2': Stra_e2,
'hausnummer': Hausnummer,
'postleitzahl': Postleitzahl,
'ort': Ort,
'postfach': Postfach,
'adresszusatz': Adresszusatz,
'breitengrad': Breitengrad,
'laengengrad': Laengengrad
};
getTypeName() => "Address";
TypeContext? context = _ctx;
}
enum UnitKind
{
L,
Kg,
CBM,
Stck,
KWH,
MWH,
GWH,
T,
RM,
Einheit,
Qm,
GJ,
MJ,
Null,
}
enum EstimationKind
{
Null,
S1,
S2,
S3,
S4,
S5,
N1,
N2,
}
enum DeviceConsumptionState
{
Null,
RMInOrdnung,
RMFehler,
RMNichtGepr,
RMFehlerTausch,
KeinWohnungszutritt,
Defekt,
FalschLaufend,
Überlauf,
EichungBeachten,
ProbeEntnommen,
ProbeZumLabor,
ProbePositiv,
ProbeNegativ,
}
enum DeviceConsumptionOrigin
{
Unbekannt,
Manual,
Emr,
Walkby,
Deleted,
}
// @DataContract
class DeviceConsumption implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Ablesedatum")
DateTime? Ablesedatum;
// @DataMember(Name="Faktor")
double? Faktor;
// @DataMember(Name="Ablesung")
double? Ablesung;
// @DataMember(Name="Verbrauch")
double? Verbrauch;
// @DataMember(Name="Aenderungsdatum")
DateTime? Aenderungsdatum;
// @DataMember(Name="Schaetzung")
EstimationKind? Schaetzung;
// @DataMember(Name="Status")
DeviceConsumptionState? Status;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="IstRekonstruiert")
bool? IstRekonstruiert;
// @DataMember(Name="Manuell")
double? Manuell;
// @DataMember(Name="Herkunft")
DeviceConsumptionOrigin? Herkunft;
// @DataMember(Name="Lufttemperatur")
double? Lufttemperatur;
// @DataMember(Name="HeizkörperTemperatur")
double? Heizk_rperTemperatur;
// @DataMember(Name="LetzterfehlerDatum")
DateTime? LetzterfehlerDatum;
// @DataMember(Name="Fehler")
String? Fehler;
// @DataMember(Name="Ampullenfarbe")
String? Ampullenfarbe;
// @DataMember(Name="AbleseartGuid")
String? AbleseartGuid;
DeviceConsumption({this.Guid,this.LastModified,this.Ablesedatum,this.Faktor,this.Ablesung,this.Verbrauch,this.Aenderungsdatum,this.Schaetzung,this.Status,this.Anmerkung,this.IstRekonstruiert,this.Manuell,this.Herkunft,this.Lufttemperatur,this.Heizk_rperTemperatur,this.LetzterfehlerDatum,this.Fehler,this.Ampullenfarbe,this.AbleseartGuid});
DeviceConsumption.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Ablesedatum = JsonConverters.fromJson(json['readingDate'],'DateTime',context!);
Faktor = JsonConverters.toDouble(json['factor']);
Ablesung = JsonConverters.toDouble(json['reading']);
Verbrauch = JsonConverters.toDouble(json['consumption']);
Aenderungsdatum = JsonConverters.fromJson(json['changeDate'],'DateTime',context!);
Schaetzung = JsonConverters.fromJson(json['estimation'],'EstimationKind',context!);
Status = JsonConverters.fromJson(json['state'],'DeviceConsumptionState',context!);
Anmerkung = json['note'];
IstRekonstruiert = json['isReconstructed'];
Manuell = JsonConverters.toDouble(json['manual']);
Herkunft = JsonConverters.fromJson(json['origin'],'DeviceConsumptionOrigin',context!);
Lufttemperatur = JsonConverters.toDouble(json['airTemperature']);
Heizk_rperTemperatur = JsonConverters.toDouble(json['radiatorTemperature']);
LetzterfehlerDatum = JsonConverters.fromJson(json['lastErrorDate'],'DateTime',context!);
Fehler = json['error'];
Ampullenfarbe = json['ampouleColour'];
AbleseartGuid = json['readindKindGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'ablesedatum': JsonConverters.toJson(Ablesedatum,'DateTime',context!),
'faktor': Faktor,
'ablesung': Ablesung,
'verbrauch': Verbrauch,
'aenderungsdatum': JsonConverters.toJson(Aenderungsdatum,'DateTime',context!),
'schaetzung': JsonConverters.toJson(Schaetzung,'EstimationKind',context!),
'status': JsonConverters.toJson(Status,'DeviceConsumptionState',context!),
'anmerkung': Anmerkung,
'istRekonstruiert': IstRekonstruiert,
'manuell': Manuell,
'herkunft': JsonConverters.toJson(Herkunft,'DeviceConsumptionOrigin',context!),
'lufttemperatur': Lufttemperatur,
'heizk_rperTemperatur': Heizk_rperTemperatur,
'letzterfehlerDatum': JsonConverters.toJson(LetzterfehlerDatum,'DateTime',context!),
'fehler': Fehler,
'ampullenfarbe': Ampullenfarbe,
'ableseartGuid': AbleseartGuid
};
getTypeName() => "DeviceConsumption";
TypeContext? context = _ctx;
}
// @DataContract
class Photo implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="Timestamp")
DateTime? Timestamp;
Photo({this.Guid,this.Timestamp});
Photo.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
Timestamp = JsonConverters.fromJson(json['recordedDate'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'timestamp': JsonConverters.toJson(Timestamp,'DateTime',context!)
};
getTypeName() => "Photo";
TypeContext? context = _ctx;
}
// @DataContract
class DeviceAdditionalArticle implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="Menge")
double? Menge;
// @DataMember(Name="LastModified")
DateTime? LastModified;
DeviceAdditionalArticle({this.Guid,this.Menge,this.LastModified});
DeviceAdditionalArticle.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['additionalArticleGuid'];
Menge = JsonConverters.toDouble(json['quantity']);
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'menge': Menge,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!)
};
getTypeName() => "DeviceAdditionalArticle";
TypeContext? context = _ctx;
}
// @DataContract
class Device implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Geraetenummer")
String? Geraetenummer;
// @DataMember(Name="Bezeichnung")
String? Bezeichnung;
// @DataMember(Name="Beschreibung")
String? Beschreibung;
// @DataMember(Name="Einbaudatum")
DateTime? Einbaudatum;
// @DataMember(Name="Ausbaudatum")
DateTime? Ausbaudatum;
// @DataMember(Name="Eichdatum")
DateTime? Eichdatum;
// @DataMember(Name="Einheit")
UnitKind? Einheit;
// @DataMember(Name="Memo")
String? Memo;
// @DataMember(Name="Abzug")
bool? Abzug;
// @DataMember(Name="GrpKennung")
String? GrpKennung;
// @DataMember(Name="Dauerschaetzung")
EstimationKind? Dauerschaetzung;
// @DataMember(Name="ErstInbetriebnahme")
DateTime? ErstInbetriebnahme;
// @DataMember(Name="FirmwareVersion")
String? FirmwareVersion;
// @DataMember(Name="RaumGuid")
String? RaumGuid;
// @DataMember(Name="LaufendeNummer")
String? LaufendeNummer;
// @DataMember(Name="Gemietet")
bool? Gemietet;
// @DataMember(Name="Gewartet")
bool? Gewartet;
// @DataMember(Name="GeraeteKatalogGuid")
String? GeraeteKatalogGuid;
// @DataMember(Name="Verbraeuche")
List<DeviceConsumption>? Verbraeuche;
// @DataMember(Name="Fotos")
List<Photo>? Fotos;
// @DataMember(Name="ZusatzArtikel")
List<DeviceAdditionalArticle>? ZusatzArtikel;
Device({this.Guid,this.LastModified,this.Geraetenummer,this.Bezeichnung,this.Beschreibung,this.Einbaudatum,this.Ausbaudatum,this.Eichdatum,this.Einheit,this.Memo,this.Abzug,this.GrpKennung,this.Dauerschaetzung,this.ErstInbetriebnahme,this.FirmwareVersion,this.RaumGuid,this.LaufendeNummer,this.Gemietet,this.Gewartet,this.GeraeteKatalogGuid,this.Verbraeuche,this.Fotos,this.ZusatzArtikel});
Device.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Geraetenummer = json['number'];
Bezeichnung = json['label'];
Beschreibung = json['description'];
Einbaudatum = JsonConverters.fromJson(json['installationDate'],'DateTime',context!);
Ausbaudatum = JsonConverters.fromJson(json['deinstallationDate'],'DateTime',context!);
Eichdatum = JsonConverters.fromJson(json['calibrationDate'],'DateTime',context!);
Einheit = JsonConverters.fromJson(json['unit'],'UnitKind',context!);
Memo = json['note'];
Abzug = json['subtraction'];
GrpKennung = json['groupIdentifier'];
Dauerschaetzung = JsonConverters.fromJson(json['estimation'],'EstimationKind',context!);
ErstInbetriebnahme = JsonConverters.fromJson(json['firstActivation'],'DateTime',context!);
FirmwareVersion = json['firmwareVersion'];
RaumGuid = json['roomGuid'];
LaufendeNummer = json['ongoingNumber'];
Gemietet = json['isLeased'];
Gewartet = json['isMaintained'];
GeraeteKatalogGuid = json['deviceCatalogGuid'];
Verbraeuche = JsonConverters.fromJson(json['deviceConsumptions'],'List<DeviceConsumption>',context!);
Fotos = JsonConverters.fromJson(json['photos'],'List<Photo>',context!);
ZusatzArtikel = JsonConverters.fromJson(json['deviceAdditionalArticles'],'List<DeviceAdditionalArticle>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'geraetenummer': Geraetenummer,
'bezeichnung': Bezeichnung,
'beschreibung': Beschreibung,
'einbaudatum': JsonConverters.toJson(Einbaudatum,'DateTime',context!),
'ausbaudatum': JsonConverters.toJson(Ausbaudatum,'DateTime',context!),
'eichdatum': JsonConverters.toJson(Eichdatum,'DateTime',context!),
'einheit': JsonConverters.toJson(Einheit,'UnitKind',context!),
'memo': Memo,
'abzug': Abzug,
'grpKennung': GrpKennung,
'dauerschaetzung': JsonConverters.toJson(Dauerschaetzung,'EstimationKind',context!),
'erstInbetriebnahme': JsonConverters.toJson(ErstInbetriebnahme,'DateTime',context!),
'firmwareVersion': FirmwareVersion,
'raumGuid': RaumGuid,
'laufendeNummer': LaufendeNummer,
'gemietet': Gemietet,
'gewartet': Gewartet,
'geraeteKatalogGuid': GeraeteKatalogGuid,
'verbraeuche': JsonConverters.toJson(Verbraeuche,'List<DeviceConsumption>',context!),
'fotos': JsonConverters.toJson(Fotos,'List<Photo>',context!),
'zusatzArtikel': JsonConverters.toJson(ZusatzArtikel,'List<DeviceAdditionalArticle>',context!)
};
getTypeName() => "Device";
TypeContext? context = _ctx;
}
enum NutzerKind
{
Leerstand,
Gewerblich,
Privat,
AllgemeineNutzung,
}
// @DataContract
class NutzerCommunication implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Adresse")
String? Adresse;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="KommunikationsFunktionGuid")
String? KommunikationsFunktionGuid;
NutzerCommunication({this.Guid,this.LastModified,this.Adresse,this.Anmerkung,this.KommunikationsFunktionGuid});
NutzerCommunication.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Adresse = json['address'];
Anmerkung = json['note'];
KommunikationsFunktionGuid = json['communicationFeatureGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'adresse': Adresse,
'anmerkung': Anmerkung,
'kommunikationsFunktionGuid': KommunikationsFunktionGuid
};
getTypeName() => "NutzerCommunication";
TypeContext? context = _ctx;
}
// @DataContract
class NutzerPersonen implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Personen")
int? Personen;
// @DataMember(Name="Von")
DateTime? Von;
// @DataMember(Name="Bis")
DateTime? Bis;
NutzerPersonen({this.Guid,this.LastModified,this.Personen,this.Von,this.Bis});
NutzerPersonen.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Personen = json['numberOfPeople'];
Von = JsonConverters.fromJson(json['rangeFrom'],'DateTime',context!);
Bis = JsonConverters.fromJson(json['rangeTo'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'personen': Personen,
'von': JsonConverters.toJson(Von,'DateTime',context!),
'bis': JsonConverters.toJson(Bis,'DateTime',context!)
};
getTypeName() => "NutzerPersonen";
TypeContext? context = _ctx;
}
// @DataContract
class NutzerCoOwnership implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="ShareValue")
double? ShareValue;
// @DataMember(Name="Von")
DateTime? Von;
// @DataMember(Name="Bis")
DateTime? Bis;
NutzerCoOwnership({this.Guid,this.LastModified,this.ShareValue,this.Von,this.Bis});
NutzerCoOwnership.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
ShareValue = JsonConverters.toDouble(json['shareValue']);
Von = JsonConverters.fromJson(json['rangeFrom'],'DateTime',context!);
Bis = JsonConverters.fromJson(json['rangeTo'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'shareValue': ShareValue,
'von': JsonConverters.toJson(Von,'DateTime',context!),
'bis': JsonConverters.toJson(Bis,'DateTime',context!)
};
getTypeName() => "NutzerCoOwnership";
TypeContext? context = _ctx;
}
// @DataContract
class NutzerQuadratmeter implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Quadratmeter_Hzg")
double? Quadratmeter_Hzg;
// @DataMember(Name="Quadratmeter_Ww")
double? Quadratmeter_Ww;
// @DataMember(Name="Quadratmeter_Nk")
double? Quadratmeter_Nk;
// @DataMember(Name="Von")
DateTime? Von;
// @DataMember(Name="Bis")
DateTime? Bis;
NutzerQuadratmeter({this.Guid,this.LastModified,this.Quadratmeter_Hzg,this.Quadratmeter_Ww,this.Quadratmeter_Nk,this.Von,this.Bis});
NutzerQuadratmeter.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Quadratmeter_Hzg = JsonConverters.toDouble(json['squareMeters_Hzg']);
Quadratmeter_Ww = JsonConverters.toDouble(json['squareMeters_Ww']);
Quadratmeter_Nk = JsonConverters.toDouble(json['squareMeters_Nk']);
Von = JsonConverters.fromJson(json['rangeFrom'],'DateTime',context!);
Bis = JsonConverters.fromJson(json['rangeTo'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'quadratmeter_Hzg': Quadratmeter_Hzg,
'quadratmeter_Ww': Quadratmeter_Ww,
'quadratmeter_Nk': Quadratmeter_Nk,
'von': JsonConverters.toJson(Von,'DateTime',context!),
'bis': JsonConverters.toJson(Bis,'DateTime',context!)
};
getTypeName() => "NutzerQuadratmeter";
TypeContext? context = _ctx;
}
// @DataContract
class Nutzer implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="ArtDerNutzung")
NutzerKind? ArtDerNutzung;
// @DataMember(Name="Einzug")
DateTime? Einzug;
// @DataMember(Name="Auszug")
DateTime? Auszug;
// @DataMember(Name="Name1")
String? Name1;
// @DataMember(Name="Name2")
String? Name2;
// @DataMember(Name="Name3")
String? Name3;
// @DataMember(Name="Name4")
String? Name4;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="NaechsterTermin")
DateTime? NaechsterTermin;
// @DataMember(Name="Anrede")
String? Anrede;
// @DataMember(Name="Titel")
String? Titel;
// @DataMember(Name="NutzerKommunikationen")
List<NutzerCommunication>? NutzerKommunikationen;
// @DataMember(Name="NutzerPersonen")
List<NutzerPersonen>? NutzerPersonen;
// @DataMember(Name="NutzerCoOwnership")
List<NutzerCoOwnership>? NutzerCoOwnership;
// @DataMember(Name="NutzerQuadratmeter")
List<NutzerQuadratmeter>? NutzerQuadratmeter;
Nutzer({this.Guid,this.LastModified,this.ArtDerNutzung,this.Einzug,this.Auszug,this.Name1,this.Name2,this.Name3,this.Name4,this.Anmerkung,this.NaechsterTermin,this.Anrede,this.Titel,this.NutzerKommunikationen,this.NutzerPersonen,this.NutzerCoOwnership,this.NutzerQuadratmeter});
Nutzer.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
ArtDerNutzung = JsonConverters.fromJson(json['kind'],'NutzerKind',context!);
Einzug = JsonConverters.fromJson(json['moveInDate'],'DateTime',context!);
Auszug = JsonConverters.fromJson(json['moveOutDate'],'DateTime',context!);
Name1 = json['name1'];
Name2 = json['name2'];
Name3 = json['name3'];
Name4 = json['name4'];
Anmerkung = json['note'];
NaechsterTermin = JsonConverters.fromJson(json['nextAppointmentDate'],'DateTime',context!);
Anrede = json['salutation'];
Titel = json['title'];
NutzerKommunikationen = JsonConverters.fromJson(json['nutzerCommunications'],'List<NutzerCommunication>',context!);
NutzerPersonen = JsonConverters.fromJson(json['nutzerPersonen'],'List<NutzerPersonen>',context!);
NutzerCoOwnership = JsonConverters.fromJson(json['nutzerCoOwnership'],'List<NutzerCoOwnership>',context!);
NutzerQuadratmeter = JsonConverters.fromJson(json['nutzerQuadratmeter'],'List<NutzerQuadratmeter>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'artDerNutzung': JsonConverters.toJson(ArtDerNutzung,'NutzerKind',context!),
'einzug': JsonConverters.toJson(Einzug,'DateTime',context!),
'auszug': JsonConverters.toJson(Auszug,'DateTime',context!),
'name1': Name1,
'name2': Name2,
'name3': Name3,
'name4': Name4,
'anmerkung': Anmerkung,
'naechsterTermin': JsonConverters.toJson(NaechsterTermin,'DateTime',context!),
'anrede': Anrede,
'titel': Titel,
'nutzerKommunikationen': JsonConverters.toJson(NutzerKommunikationen,'List<NutzerCommunication>',context!),
'nutzerPersonen': JsonConverters.toJson(NutzerPersonen,'List<NutzerPersonen>',context!),
'nutzerCoOwnership': JsonConverters.toJson(NutzerCoOwnership,'List<NutzerCoOwnership>',context!),
'nutzerQuadratmeter': JsonConverters.toJson(NutzerQuadratmeter,'List<NutzerQuadratmeter>',context!)
};
getTypeName() => "Nutzer";
TypeContext? context = _ctx;
}
class Nutzeinheit implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="NeNummerInt")
String? NeNummerInt;
// @DataMember(Name="Lage")
String? Lage;
// @DataMember(Name="BegeReihenfolge")
String? BegeReihenfolge;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="AbrechnungseinheitGuid")
String? AbrechnungseinheitGuid;
// @DataMember(Name="Adresse")
Address? Adresse;
// @DataMember(Name="Geraete")
List<Device>? Geraete;
// @DataMember(Name="Nutzer")
List<Nutzer>? Nutzer;
// @DataMember(Name="Fotos")
List<Photo>? Fotos;
Nutzeinheit({this.Guid,this.LastModified,this.NeNummerInt,this.Lage,this.BegeReihenfolge,this.Anmerkung,this.AbrechnungseinheitGuid,this.Adresse,this.Geraete,this.Nutzer,this.Fotos});
Nutzeinheit.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
NeNummerInt = json['number'];
Lage = json['location'];
BegeReihenfolge = json['walkSequence'];
Anmerkung = json['note'];
AbrechnungseinheitGuid = json['abrechnungseinheitGuid'];
Adresse = JsonConverters.fromJson(json['address'],'Address',context!);
Geraete = JsonConverters.fromJson(json['devices'],'List<Device>',context!);
Nutzer = JsonConverters.fromJson(json['nutzer'],'List<Nutzer>',context!);
Fotos = JsonConverters.fromJson(json['photos'],'List<Photo>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'neNummerInt': NeNummerInt,
'lage': Lage,
'begeReihenfolge': BegeReihenfolge,
'anmerkung': Anmerkung,
'abrechnungseinheitGuid': AbrechnungseinheitGuid,
'adresse': JsonConverters.toJson(Adresse,'Address',context!),
'geraete': JsonConverters.toJson(Geraete,'List<Device>',context!),
'nutzer': JsonConverters.toJson(Nutzer,'List<Nutzer>',context!),
'fotos': JsonConverters.toJson(Fotos,'List<Photo>',context!)
};
getTypeName() => "Nutzeinheit";
TypeContext? context = _ctx;
}
enum ProcessState
{
InProgress,
Updating,
Creating,
Completed,
}
// @DataContract
class OrderState implements IConvertible
{
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="AuftragArten")
List<OrderKind>? AuftragArten;
// @DataMember(Name="Bearbeitungsstatus")
ProcessState? Bearbeitungsstatus;
// @DataMember(Name="AbgeschlossenDatum")
DateTime? AbgeschlossenDatum;
OrderState({this.LastModified,this.AuftragArten,this.Bearbeitungsstatus,this.AbgeschlossenDatum});
OrderState.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
AuftragArten = JsonConverters.fromJson(json['kinds'],'List<OrderKind>',context!);
Bearbeitungsstatus = JsonConverters.fromJson(json['processState'],'ProcessState',context!);
AbgeschlossenDatum = JsonConverters.fromJson(json['completedDate'],'DateTime',context!);
return this;
}
Map<String, dynamic> toJson() => {
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'auftragArten': JsonConverters.toJson(AuftragArten,'List<OrderKind>',context!),
'bearbeitungsstatus': JsonConverters.toJson(Bearbeitungsstatus,'ProcessState',context!),
'abgeschlossenDatum': JsonConverters.toJson(AbgeschlossenDatum,'DateTime',context!)
};
getTypeName() => "OrderState";
TypeContext? context = _ctx;
}
// @DataContract
class AppointmentStoreUser implements IConvertible
{
// @DataMember(Name="MonteurGuid")
String? MonteurGuid;
AppointmentStoreUser({this.MonteurGuid});
AppointmentStoreUser.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
MonteurGuid = json['storeUserId'];
return this;
}
Map<String, dynamic> toJson() => {
'monteurGuid': MonteurGuid
};
getTypeName() => "AppointmentStoreUser";
TypeContext? context = _ctx;
}
// @DataContract
class AppointmentNutzeinheit implements IConvertible
{
// @DataMember(Name="NutzeinheitGuid")
String? NutzeinheitGuid;
AppointmentNutzeinheit({this.NutzeinheitGuid});
AppointmentNutzeinheit.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
NutzeinheitGuid = json['nutzeinheitGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'nutzeinheitGuid': NutzeinheitGuid
};
getTypeName() => "AppointmentNutzeinheit";
TypeContext? context = _ctx;
}
// @DataContract
class Appointment implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="Von")
DateTime? Von;
// @DataMember(Name="Bis")
DateTime? Bis;
// @DataMember(Name="Monteure")
List<AppointmentStoreUser>? Monteure;
// @DataMember(Name="Nutzeinheiten")
List<AppointmentNutzeinheit>? Nutzeinheiten;
Appointment({this.Guid,this.Von,this.Bis,this.Monteure,this.Nutzeinheiten});
Appointment.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
Von = JsonConverters.fromJson(json['from'],'DateTime',context!);
Bis = JsonConverters.fromJson(json['to'],'DateTime',context!);
Monteure = JsonConverters.fromJson(json['appointmentStoreUsers'],'List<AppointmentStoreUser>',context!);
Nutzeinheiten = JsonConverters.fromJson(json['appointmentNutzeinheiten'],'List<AppointmentNutzeinheit>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'von': JsonConverters.toJson(Von,'DateTime',context!),
'bis': JsonConverters.toJson(Bis,'DateTime',context!),
'monteure': JsonConverters.toJson(Monteure,'List<AppointmentStoreUser>',context!),
'nutzeinheiten': JsonConverters.toJson(Nutzeinheiten,'List<AppointmentNutzeinheit>',context!)
};
getTypeName() => "Appointment";
TypeContext? context = _ctx;
}
// @DataContract
class NutzeinheitOrderPosition implements IConvertible
{
// @DataMember(Name="NutzeinheitGuid")
String? NutzeinheitGuid;
NutzeinheitOrderPosition({this.NutzeinheitGuid});
NutzeinheitOrderPosition.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
NutzeinheitGuid = json['nutzeinheitGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'nutzeinheitGuid': NutzeinheitGuid
};
getTypeName() => "NutzeinheitOrderPosition";
TypeContext? context = _ctx;
}
// @DataContract
class OrderPosition implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="SollMenge")
int? SollMenge;
// @DataMember(Name="IstMenge")
int? IstMenge;
// @DataMember(Name="NutzeinheitOrderPositions")
List<NutzeinheitOrderPosition>? NutzeinheitOrderPositions;
// @DataMember(Name="ArtikelGuid")
String? ArtikelGuid;
OrderPosition({this.Guid,this.LastModified,this.Anmerkung,this.SollMenge,this.IstMenge,this.NutzeinheitOrderPositions,this.ArtikelGuid});
OrderPosition.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Anmerkung = json['note'];
SollMenge = json['requiredQuantity'];
IstMenge = json['actualQuantity'];
NutzeinheitOrderPositions = JsonConverters.fromJson(json['nutzeinheitOrderPositions'],'List<NutzeinheitOrderPosition>',context!);
ArtikelGuid = json['articleGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'anmerkung': Anmerkung,
'sollMenge': SollMenge,
'istMenge': IstMenge,
'nutzeinheitOrderPositions': JsonConverters.toJson(NutzeinheitOrderPositions,'List<NutzeinheitOrderPosition>',context!),
'artikelGuid': ArtikelGuid
};
getTypeName() => "OrderPosition";
TypeContext? context = _ctx;
}
// @DataContract
class NutzeinheitOrderState implements IConvertible
{
// @DataMember(Name="NutzeinheitGuid")
String? NutzeinheitGuid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="AuftragArten")
List<NutzeinheitOrderKind>? AuftragArten;
// @DataMember(Name="Bearbeitungsstatus")
ProcessState? Bearbeitungsstatus;
// @DataMember(Name="AbgeschlossenDatum")
DateTime? AbgeschlossenDatum;
// @DataMember(Name="OsVersion")
String? OsVersion;
// @DataMember(Name="AppVersion")
String? AppVersion;
// @DataMember(Name="OsPlatform")
String? OsPlatform;
// @DataMember(Name="AppGeraeteNummmer")
String? AppGeraeteNummmer;
// @DataMember(Name="AmwInfoKeyGuid")
String? AmwInfoKeyGuid;
NutzeinheitOrderState({this.NutzeinheitGuid,this.LastModified,this.AuftragArten,this.Bearbeitungsstatus,this.AbgeschlossenDatum,this.OsVersion,this.AppVersion,this.OsPlatform,this.AppGeraeteNummmer,this.AmwInfoKeyGuid});
NutzeinheitOrderState.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
NutzeinheitGuid = json['nutzeinheitGuid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
AuftragArten = JsonConverters.fromJson(json['orderKinds'],'List<NutzeinheitOrderKind>',context!);
Bearbeitungsstatus = JsonConverters.fromJson(json['processState'],'ProcessState',context!);
AbgeschlossenDatum = JsonConverters.fromJson(json['completedDate'],'DateTime',context!);
OsVersion = json['osVersion'];
AppVersion = json['appVersion'];
OsPlatform = json['osPlatform'];
AppGeraeteNummmer = json['appDeviceNumber'];
AmwInfoKeyGuid = json['amwInfoKeyGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'nutzeinheitGuid': NutzeinheitGuid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'auftragArten': JsonConverters.toJson(AuftragArten,'List<NutzeinheitOrderKind>',context!),
'bearbeitungsstatus': JsonConverters.toJson(Bearbeitungsstatus,'ProcessState',context!),
'abgeschlossenDatum': JsonConverters.toJson(AbgeschlossenDatum,'DateTime',context!),
'osVersion': OsVersion,
'appVersion': AppVersion,
'osPlatform': OsPlatform,
'appGeraeteNummmer': AppGeraeteNummmer,
'amwInfoKeyGuid': AmwInfoKeyGuid
};
getTypeName() => "NutzeinheitOrderState";
TypeContext? context = _ctx;
}
enum DeviceOrderKind
{
Assembly,
Maintenance,
Exchange,
Reading,
Inspection,
MainReading,
}
// @DataContract
class DeviceOrderState implements IConvertible
{
// @DataMember(Name="GeraeteGuid")
String? GeraeteGuid;
// @DataMember(Name="AuftragGuid")
String? AuftragGuid;
// @DataMember(Name="AuftragArt")
DeviceOrderKind? AuftragArt;
// @DataMember(Name="Bearbeitungsstatus")
ProcessState? Bearbeitungsstatus;
// @DataMember(Name="AbgeschlossenDatum")
DateTime? AbgeschlossenDatum;
// @DataMember(Name="AmwInfo")
String? AmwInfo;
DeviceOrderState({this.GeraeteGuid,this.AuftragGuid,this.AuftragArt,this.Bearbeitungsstatus,this.AbgeschlossenDatum,this.AmwInfo});
DeviceOrderState.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
GeraeteGuid = json['deviceGuid'];
AuftragGuid = json['orderGuid'];
AuftragArt = JsonConverters.fromJson(json['orderKind'],'DeviceOrderKind',context!);
Bearbeitungsstatus = JsonConverters.fromJson(json['processState'],'ProcessState',context!);
AbgeschlossenDatum = JsonConverters.fromJson(json['completedDate'],'DateTime',context!);
AmwInfo = json['amwInfo'];
return this;
}
Map<String, dynamic> toJson() => {
'geraeteGuid': GeraeteGuid,
'auftragGuid': AuftragGuid,
'auftragArt': JsonConverters.toJson(AuftragArt,'DeviceOrderKind',context!),
'bearbeitungsstatus': JsonConverters.toJson(Bearbeitungsstatus,'ProcessState',context!),
'abgeschlossenDatum': JsonConverters.toJson(AbgeschlossenDatum,'DateTime',context!),
'amwInfo': AmwInfo
};
getTypeName() => "DeviceOrderState";
TypeContext? context = _ctx;
}
// @DataContract
class PersonCommunication implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Adresse")
String? Adresse;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="KommunikationsFunktionGuid")
String? KommunikationsFunktionGuid;
PersonCommunication({this.Guid,this.LastModified,this.Adresse,this.Anmerkung,this.KommunikationsFunktionGuid});
PersonCommunication.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Adresse = json['address'];
Anmerkung = json['note'];
KommunikationsFunktionGuid = json['communicationFeatureGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'adresse': Adresse,
'anmerkung': Anmerkung,
'kommunikationsFunktionGuid': KommunikationsFunktionGuid
};
getTypeName() => "PersonCommunication";
TypeContext? context = _ctx;
}
// @DataContract
class Person implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Nachname1")
String? Nachname1;
// @DataMember(Name="Nachname2")
String? Nachname2;
// @DataMember(Name="Nachname3")
String? Nachname3;
// @DataMember(Name="Vorname1")
String? Vorname1;
// @DataMember(Name="Vorname2")
String? Vorname2;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="Anrede")
String? Anrede;
// @DataMember(Name="Titel")
String? Titel;
// @DataMember(Name="PersonKommunikationen")
List<PersonCommunication>? PersonKommunikationen;
Person({this.Guid,this.LastModified,this.Nachname1,this.Nachname2,this.Nachname3,this.Vorname1,this.Vorname2,this.Anmerkung,this.Anrede,this.Titel,this.PersonKommunikationen});
Person.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Nachname1 = json['lastname1'];
Nachname2 = json['lastname2'];
Nachname3 = json['lastname3'];
Vorname1 = json['firstname1'];
Vorname2 = json['firstname2'];
Anmerkung = json['note'];
Anrede = json['salutation'];
Titel = json['title'];
PersonKommunikationen = JsonConverters.fromJson(json['personCommunications'],'List<PersonCommunication>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'nachname1': Nachname1,
'nachname2': Nachname2,
'nachname3': Nachname3,
'vorname1': Vorname1,
'vorname2': Vorname2,
'anmerkung': Anmerkung,
'anrede': Anrede,
'titel': Titel,
'personKommunikationen': JsonConverters.toJson(PersonKommunikationen,'List<PersonCommunication>',context!)
};
getTypeName() => "Person";
TypeContext? context = _ctx;
}
// @DataContract
class Orderer implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="Person")
Person? Person;
// @DataMember(Name="BetrieblichePosition")
String? BetrieblichePosition;
Orderer({this.Guid,this.Person,this.BetrieblichePosition});
Orderer.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
Person = JsonConverters.fromJson(json['person'],'Person',context!);
BetrieblichePosition = json['businessPosition'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'person': JsonConverters.toJson(Person,'Person',context!),
'betrieblichePosition': BetrieblichePosition
};
getTypeName() => "Orderer";
TypeContext? context = _ctx;
}
enum SignatureKind
{
Nutzer,
Technician,
}
// @DataContract
class Signature implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="Timestamp")
DateTime? Timestamp;
// @DataMember(Name="UnterschriftArt")
SignatureKind? UnterschriftArt;
// @DataMember(Name="NutzeinheitGuid")
String? NutzeinheitGuid;
Signature({this.Guid,this.Timestamp,this.UnterschriftArt,this.NutzeinheitGuid});
Signature.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
Timestamp = JsonConverters.fromJson(json['recordedDate'],'DateTime',context!);
UnterschriftArt = JsonConverters.fromJson(json['kind'],'SignatureKind',context!);
NutzeinheitGuid = json['nutzeinheitGuid'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'timestamp': JsonConverters.toJson(Timestamp,'DateTime',context!),
'unterschriftArt': JsonConverters.toJson(UnterschriftArt,'SignatureKind',context!),
'nutzeinheitGuid': NutzeinheitGuid
};
getTypeName() => "Signature";
TypeContext? context = _ctx;
}
// @DataContract
class Order implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="AbrechnungseinheitGuid")
String? AbrechnungseinheitGuid;
// @DataMember(Name="AuftragNummer")
String? AuftragNummer;
// @DataMember(Name="Bezeichnung")
String? Bezeichnung;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="UnterschriftBenoetigt")
bool? UnterschriftBenoetigt;
// @DataMember(Name="Erstellungsdatum")
DateTime? Erstellungsdatum;
// @DataMember(Name="AuftragZustand")
OrderState? AuftragZustand;
// @DataMember(Name="Termine")
List<Appointment>? Termine;
// @DataMember(Name="AuftragsPositionen")
List<OrderPosition>? AuftragsPositionen;
// @DataMember(Name="NutzeinheitZustaende")
List<NutzeinheitOrderState>? NutzeinheitZustaende;
// @DataMember(Name="GeraeteZustaende")
List<DeviceOrderState>? GeraeteZustaende;
// @DataMember(Name="Auftraggeber")
Orderer? Auftraggeber;
// @DataMember(Name="Unterschriften")
List<Signature>? Unterschriften;
Order({this.Guid,this.LastModified,this.AbrechnungseinheitGuid,this.AuftragNummer,this.Bezeichnung,this.Anmerkung,this.UnterschriftBenoetigt,this.Erstellungsdatum,this.AuftragZustand,this.Termine,this.AuftragsPositionen,this.NutzeinheitZustaende,this.GeraeteZustaende,this.Auftraggeber,this.Unterschriften});
Order.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
AbrechnungseinheitGuid = json['abrechnungseinheitGuid'];
AuftragNummer = json['number'];
Bezeichnung = json['label'];
Anmerkung = json['note'];
UnterschriftBenoetigt = json['isSignatureRequired'];
Erstellungsdatum = JsonConverters.fromJson(json['createdDate'],'DateTime',context!);
AuftragZustand = JsonConverters.fromJson(json['orderState'],'OrderState',context!);
Termine = JsonConverters.fromJson(json['appointments'],'List<Appointment>',context!);
AuftragsPositionen = JsonConverters.fromJson(json['orderPositions'],'List<OrderPosition>',context!);
NutzeinheitZustaende = JsonConverters.fromJson(json['nutzeinheitOrderStates'],'List<NutzeinheitOrderState>',context!);
GeraeteZustaende = JsonConverters.fromJson(json['deviceOrderStates'],'List<DeviceOrderState>',context!);
Auftraggeber = JsonConverters.fromJson(json['orderer'],'Orderer',context!);
Unterschriften = JsonConverters.fromJson(json['signatures'],'List<Signature>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'abrechnungseinheitGuid': AbrechnungseinheitGuid,
'auftragNummer': AuftragNummer,
'bezeichnung': Bezeichnung,
'anmerkung': Anmerkung,
'unterschriftBenoetigt': UnterschriftBenoetigt,
'erstellungsdatum': JsonConverters.toJson(Erstellungsdatum,'DateTime',context!),
'auftragZustand': JsonConverters.toJson(AuftragZustand,'OrderState',context!),
'termine': JsonConverters.toJson(Termine,'List<Appointment>',context!),
'auftragsPositionen': JsonConverters.toJson(AuftragsPositionen,'List<OrderPosition>',context!),
'nutzeinheitZustaende': JsonConverters.toJson(NutzeinheitZustaende,'List<NutzeinheitOrderState>',context!),
'geraeteZustaende': JsonConverters.toJson(GeraeteZustaende,'List<DeviceOrderState>',context!),
'auftraggeber': JsonConverters.toJson(Auftraggeber,'Orderer',context!),
'unterschriften': JsonConverters.toJson(Unterschriften,'List<Signature>',context!)
};
getTypeName() => "Order";
TypeContext? context = _ctx;
}
// @DataContract
class Customer implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="Name")
String? Name;
// @DataMember(Name="Name2")
String? Name2;
// @DataMember(Name="Name3")
String? Name3;
// @DataMember(Name="Kundennummer")
String? Kundennummer;
// @DataMember(Name="Notiz")
String? Notiz;
// @DataMember(Name="Anrede")
String? Anrede;
Customer({this.Guid,this.Name,this.Name2,this.Name3,this.Kundennummer,this.Notiz,this.Anrede});
Customer.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
Name = json['name'];
Name2 = json['name2'];
Name3 = json['name3'];
Kundennummer = json['number'];
Notiz = json['note'];
Anrede = json['salutation'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'name': Name,
'name2': Name2,
'name3': Name3,
'kundennummer': Kundennummer,
'notiz': Notiz,
'anrede': Anrede
};
getTypeName() => "Customer";
TypeContext? context = _ctx;
}
// @DataContract
class PersonAbrechnungseinheit implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Anmerkung")
String? Anmerkung;
// @DataMember(Name="PersonGuid")
String? PersonGuid;
// @DataMember(Name="BetrieblichePosition")
String? BetrieblichePosition;
PersonAbrechnungseinheit({this.Guid,this.LastModified,this.Anmerkung,this.PersonGuid,this.BetrieblichePosition});
PersonAbrechnungseinheit.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Anmerkung = json['note'];
PersonGuid = json['personGuid'];
BetrieblichePosition = json['businessPosition'];
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'anmerkung': Anmerkung,
'personGuid': PersonGuid,
'betrieblichePosition': BetrieblichePosition
};
getTypeName() => "PersonAbrechnungseinheit";
TypeContext? context = _ctx;
}
class Abrechnungseinheit implements IConvertible
{
// @DataMember(Name="Guid")
String? Guid;
// @DataMember(Name="LastModified")
DateTime? LastModified;
// @DataMember(Name="Objektnummer")
String? Objektnummer;
// @DataMember(Name="Notiz")
String? Notiz;
// @DataMember(Name="NotizIntern")
String? NotizIntern;
// @DataMember(Name="NotizLegionellen")
String? NotizLegionellen;
// @DataMember(Name="Kunde")
Customer? Kunde;
// @DataMember(Name="Adresse")
Address? Adresse;
// @DataMember(Name="BillingPeriodEnd")
DateTime? BillingPeriodEnd;
// @DataMember(Name="PersonAbrechnungseinheit")
List<PersonAbrechnungseinheit>? PersonAbrechnungseinheit;
// @DataMember(Name="Persons")
List<Person>? Persons;
Abrechnungseinheit({this.Guid,this.LastModified,this.Objektnummer,this.Notiz,this.NotizIntern,this.NotizLegionellen,this.Kunde,this.Adresse,this.BillingPeriodEnd,this.PersonAbrechnungseinheit,this.Persons});
Abrechnungseinheit.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Guid = json['guid'];
LastModified = JsonConverters.fromJson(json['lastModified'],'DateTime',context!);
Objektnummer = json['number'];
Notiz = json['note'];
NotizIntern = json['noteInternal'];
NotizLegionellen = json['noteLegionella'];
Kunde = JsonConverters.fromJson(json['customer'],'Customer',context!);
Adresse = JsonConverters.fromJson(json['address'],'Address',context!);
BillingPeriodEnd = JsonConverters.fromJson(json['billigPeriodEnd'],'DateTime',context!);
PersonAbrechnungseinheit = JsonConverters.fromJson(json['personAbrechnungseinheiten'],'List<PersonAbrechnungseinheit>',context!);
Persons = JsonConverters.fromJson(json['persons'],'List<Person>',context!);
return this;
}
Map<String, dynamic> toJson() => {
'guid': Guid,
'lastModified': JsonConverters.toJson(LastModified,'DateTime',context!),
'objektnummer': Objektnummer,
'notiz': Notiz,
'notizIntern': NotizIntern,
'notizLegionellen': NotizLegionellen,
'kunde': JsonConverters.toJson(Kunde,'Customer',context!),
'adresse': JsonConverters.toJson(Adresse,'Address',context!),
'billingPeriodEnd': JsonConverters.toJson(BillingPeriodEnd,'DateTime',context!),
'personAbrechnungseinheit': JsonConverters.toJson(PersonAbrechnungseinheit,'List<PersonAbrechnungseinheit>',context!),
'persons': JsonConverters.toJson(Persons,'List<Person>',context!)
};
getTypeName() => "Abrechnungseinheit";
TypeContext? context = _ctx;
}
class GetNotesResponse implements IConvertible
{
// @DataMember(Name="Nutzeinheiten")
List<Nutzeinheit>? Nutzeinheiten;
// @DataMember(Name="Orders")
List<Order>? Orders;
// @DataMember(Name="Abrechnungseinheiten")
List<Abrechnungseinheit>? Abrechnungseinheiten;
ResponseStatus? responseStatus;
GetNotesResponse({this.Nutzeinheiten,this.Orders,this.Abrechnungseinheiten,this.responseStatus});
GetNotesResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }
fromMap(Map<String, dynamic> json) {
Nutzeinheiten = JsonConverters.fromJson(json['nutzeinheiten'],'List<Nutzeinheit>',context!);
Orders = JsonConverters.fromJson(json['orders'],'List<Order>',context!);
Abrechnungseinheiten = JsonConverters.fromJson(json['abrechnungseinheiten'],'List<Abrechnungseinheit>',context!);
responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
return this;
}
Map<String, dynamic> toJson() => {
'nutzeinheiten': JsonConverters.toJson(Nutzeinheiten,'List<Nutzeinheit>',context!),
'orders': JsonConverters.toJson(Orders,'List<Order>',context!),
'abrechnungseinheiten': JsonConverters.toJson(Abrechnungseinheiten,'List<Abrechnungseinheit>',context!),
'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
};
getTypeName() => "GetNotesResponse";
TypeContext? context = _ctx;
}
// @DataContract
class GetNotes extends Eras2AppServiceModelBase implements IConvertible
{
GetNotes();
GetNotes.fromJson(Map<String, dynamic> json) : super.fromJson(json);
fromMap(Map<String, dynamic> json) {
super.fromMap(json);
return this;
}
Map<String, dynamic> toJson() => super.toJson();
getTypeName() => "GetNotes";
TypeContext? context = _ctx;
}
TypeContext _ctx = TypeContext(library: 'mitchell_servamw.eras_online.de', types: <String, TypeInfo> {
'Eras2AppServiceModelBase': TypeInfo(TypeOf.AbstractClass),
'Address': TypeInfo(TypeOf.Class, create:() => Address()),
'UnitKind': TypeInfo(TypeOf.Enum, enumValues:UnitKind.values),
'EstimationKind': TypeInfo(TypeOf.Enum, enumValues:EstimationKind.values),
'DeviceConsumptionState': TypeInfo(TypeOf.Enum, enumValues:DeviceConsumptionState.values),
'DeviceConsumptionOrigin': TypeInfo(TypeOf.Enum, enumValues:DeviceConsumptionOrigin.values),
'DeviceConsumption': TypeInfo(TypeOf.Class, create:() => DeviceConsumption()),
'Photo': TypeInfo(TypeOf.Class, create:() => Photo()),
'DeviceAdditionalArticle': TypeInfo(TypeOf.Class, create:() => DeviceAdditionalArticle()),
'Device': TypeInfo(TypeOf.Class, create:() => Device()),
'List<DeviceConsumption>': TypeInfo(TypeOf.Class, create:() => <DeviceConsumption>[]),
'List<Photo>': TypeInfo(TypeOf.Class, create:() => <Photo>[]),
'List<DeviceAdditionalArticle>': TypeInfo(TypeOf.Class, create:() => <DeviceAdditionalArticle>[]),
'NutzerKind': TypeInfo(TypeOf.Enum, enumValues:NutzerKind.values),
'NutzerCommunication': TypeInfo(TypeOf.Class, create:() => NutzerCommunication()),
'NutzerPersonen': TypeInfo(TypeOf.Class, create:() => NutzerPersonen()),
'NutzerCoOwnership': TypeInfo(TypeOf.Class, create:() => NutzerCoOwnership()),
'NutzerQuadratmeter': TypeInfo(TypeOf.Class, create:() => NutzerQuadratmeter()),
'Nutzer': TypeInfo(TypeOf.Class, create:() => Nutzer()),
'List<NutzerCommunication>': TypeInfo(TypeOf.Class, create:() => <NutzerCommunication>[]),
'List<NutzerPersonen>': TypeInfo(TypeOf.Class, create:() => <NutzerPersonen>[]),
'List<NutzerCoOwnership>': TypeInfo(TypeOf.Class, create:() => <NutzerCoOwnership>[]),
'List<NutzerQuadratmeter>': TypeInfo(TypeOf.Class, create:() => <NutzerQuadratmeter>[]),
'Nutzeinheit': TypeInfo(TypeOf.Class, create:() => Nutzeinheit()),
'List<Device>': TypeInfo(TypeOf.Class, create:() => <Device>[]),
'List<Nutzer>': TypeInfo(TypeOf.Class, create:() => <Nutzer>[]),
'ProcessState': TypeInfo(TypeOf.Enum, enumValues:ProcessState.values),
'OrderState': TypeInfo(TypeOf.Class, create:() => OrderState()),
'List<OrderKind>': TypeInfo(TypeOf.Class, create:() => <OrderKind>[]),
'OrderKind': TypeInfo(TypeOf.Class, create:() => OrderKind()),
'AppointmentStoreUser': TypeInfo(TypeOf.Class, create:() => AppointmentStoreUser()),
'AppointmentNutzeinheit': TypeInfo(TypeOf.Class, create:() => AppointmentNutzeinheit()),
'Appointment': TypeInfo(TypeOf.Class, create:() => Appointment()),
'List<AppointmentStoreUser>': TypeInfo(TypeOf.Class, create:() => <AppointmentStoreUser>[]),
'List<AppointmentNutzeinheit>': TypeInfo(TypeOf.Class, create:() => <AppointmentNutzeinheit>[]),
'NutzeinheitOrderPosition': TypeInfo(TypeOf.Class, create:() => NutzeinheitOrderPosition()),
'OrderPosition': TypeInfo(TypeOf.Class, create:() => OrderPosition()),
'List<NutzeinheitOrderPosition>': TypeInfo(TypeOf.Class, create:() => <NutzeinheitOrderPosition>[]),
'NutzeinheitOrderState': TypeInfo(TypeOf.Class, create:() => NutzeinheitOrderState()),
'List<NutzeinheitOrderKind>': TypeInfo(TypeOf.Class, create:() => <NutzeinheitOrderKind>[]),
'NutzeinheitOrderKind': TypeInfo(TypeOf.Class, create:() => NutzeinheitOrderKind()),
'DeviceOrderKind': TypeInfo(TypeOf.Enum, enumValues:DeviceOrderKind.values),
'DeviceOrderState': TypeInfo(TypeOf.Class, create:() => DeviceOrderState()),
'PersonCommunication': TypeInfo(TypeOf.Class, create:() => PersonCommunication()),
'Person': TypeInfo(TypeOf.Class, create:() => Person()),
'List<PersonCommunication>': TypeInfo(TypeOf.Class, create:() => <PersonCommunication>[]),
'Orderer': TypeInfo(TypeOf.Class, create:() => Orderer()),
'SignatureKind': TypeInfo(TypeOf.Enum, enumValues:SignatureKind.values),
'Signature': TypeInfo(TypeOf.Class, create:() => Signature()),
'Order': TypeInfo(TypeOf.Class, create:() => Order()),
'List<Appointment>': TypeInfo(TypeOf.Class, create:() => <Appointment>[]),
'List<OrderPosition>': TypeInfo(TypeOf.Class, create:() => <OrderPosition>[]),
'List<NutzeinheitOrderState>': TypeInfo(TypeOf.Class, create:() => <NutzeinheitOrderState>[]),
'List<DeviceOrderState>': TypeInfo(TypeOf.Class, create:() => <DeviceOrderState>[]),
'List<Signature>': TypeInfo(TypeOf.Class, create:() => <Signature>[]),
'Customer': TypeInfo(TypeOf.Class, create:() => Customer()),
'PersonAbrechnungseinheit': TypeInfo(TypeOf.Class, create:() => PersonAbrechnungseinheit()),
'Abrechnungseinheit': TypeInfo(TypeOf.Class, create:() => Abrechnungseinheit()),
'List<PersonAbrechnungseinheit>': TypeInfo(TypeOf.Class, create:() => <PersonAbrechnungseinheit>[]),
'List<Person>': TypeInfo(TypeOf.Class, create:() => <Person>[]),
'GetNotesResponse': TypeInfo(TypeOf.Class, create:() => GetNotesResponse()),
'List<Nutzeinheit>': TypeInfo(TypeOf.Class, create:() => <Nutzeinheit>[]),
'List<Order>': TypeInfo(TypeOf.Class, create:() => <Order>[]),
'List<Abrechnungseinheit>': TypeInfo(TypeOf.Class, create:() => <Abrechnungseinheit>[]),
'GetNotes': TypeInfo(TypeOf.Class, create:() => GetNotes()),
});
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 /App/{UserId}/Status/Notes HTTP/1.1
Host: mitchell-servamw.eras-online.de
Accept: text/jsv
HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length
{
Nutzeinheiten:
[
{
Guid: 00000000000000000000000000000000,
LastModified: 0001-01-01T00:00:00Z,
NeNummerInt: String,
Lage: String,
BegeReihenfolge: String,
Anmerkung: String,
AbrechnungseinheitGuid: 00000000000000000000000000000000,
Adresse:
{
Guid: 00000000000000000000000000000000,
Straße: String,
Straße2: String,
Hausnummer: String,
Postleitzahl: String,
Ort: String,
Postfach: String,
Adresszusatz: String,
Breitengrad: 0,
Laengengrad: 0
}
}
],
Orders:
[
{
Guid: 00000000000000000000000000000000,
LastModified: 0001-01-01T00:00:00Z,
AbrechnungseinheitGuid: 00000000000000000000000000000000,
AuftragNummer: String,
Bezeichnung: String,
Anmerkung: String,
UnterschriftBenoetigt: False,
Erstellungsdatum: 0001-01-01T00:00:00Z,
AuftragZustand:
{
LastModified: 0001-01-01T00:00:00Z,
Bearbeitungsstatus: InProgress,
AbgeschlossenDatum: 0001-01-01T00:00:00Z
},
Auftraggeber:
{
Guid: 00000000000000000000000000000000,
Person:
{
Guid: 00000000000000000000000000000000,
LastModified: 0001-01-01T00:00:00Z,
Nachname1: String,
Nachname2: String,
Nachname3: String,
Vorname1: String,
Vorname2: String,
Anmerkung: String,
Anrede: String,
Titel: String
},
BetrieblichePosition: String
}
}
],
Abrechnungseinheiten:
[
{
Guid: 00000000000000000000000000000000,
LastModified: 0001-01-01T00:00:00Z,
Objektnummer: String,
Notiz: String,
NotizIntern: String,
NotizLegionellen: String,
Kunde:
{
Guid: 00000000000000000000000000000000,
Name: String,
Name2: String,
Name3: String,
Kundennummer: String,
Notiz: String,
Anrede: String
},
Adresse:
{
Guid: 00000000000000000000000000000000,
Straße: String,
Straße2: String,
Hausnummer: String,
Postleitzahl: String,
Ort: String,
Postfach: String,
Adresszusatz: String,
Breitengrad: 0,
Laengengrad: 0
},
BillingPeriodEnd: 0001-01-01T00:00:00Z
}
],
responseStatus:
{
errorCode: String,
message: String,
stackTrace: String,
errors:
[
{
errorCode: String,
fieldName: String,
message: String,
meta:
{
String: String
}
}
],
meta:
{
String: String
}
}
}