Server

GetAppointmentsByDate

The following routes are available for this service:
GET	/WebApp/Appointments/ByDate/{FromDate}

import 'package:servicestack/servicestack.dart';
import 'dart:typed_data';

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;
}

class GetAppointmentsByDateResponse implements IConvertible
{
    List<Order>? orders;
    int? totalNutzeinheiten;
    int? completedNutzeinheiten;
    int? totalDevices;
    int? completedDevices;
    ResponseStatus? responseStatus;
    int? amwInfoKeyNutzeinheiten;
    int? amwInfoKeyDevices;

    GetAppointmentsByDateResponse({this.orders,this.totalNutzeinheiten,this.completedNutzeinheiten,this.totalDevices,this.completedDevices,this.responseStatus,this.amwInfoKeyNutzeinheiten,this.amwInfoKeyDevices});
    GetAppointmentsByDateResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        orders = JsonConverters.fromJson(json['orders'],'List<Order>',context!);
        totalNutzeinheiten = json['totalNutzeinheiten'];
        completedNutzeinheiten = json['completedNutzeinheiten'];
        totalDevices = json['totalDevices'];
        completedDevices = json['completedDevices'];
        responseStatus = JsonConverters.fromJson(json['responseStatus'],'ResponseStatus',context!);
        amwInfoKeyNutzeinheiten = json['amwInfoKeyNutzeinheiten'];
        amwInfoKeyDevices = json['amwInfoKeyDevices'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'orders': JsonConverters.toJson(orders,'List<Order>',context!),
        'totalNutzeinheiten': totalNutzeinheiten,
        'completedNutzeinheiten': completedNutzeinheiten,
        'totalDevices': totalDevices,
        'completedDevices': completedDevices,
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!),
        'amwInfoKeyNutzeinheiten': amwInfoKeyNutzeinheiten,
        'amwInfoKeyDevices': amwInfoKeyDevices
    };

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

// @DataContract
class GetAppointmentsByDate implements IConvertible
{
    // @DataMember(Name="FromDate")
    DateTime? FromDate;

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

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

    Map<String, dynamic> toJson() => {
        'fromDate': JsonConverters.toJson(FromDate,'DateTime',context!)
    };

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

TypeContext _ctx = TypeContext(library: 'immo_account_servamw.eras_online.de', types: <String, TypeInfo> {
    '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>[]),
    'GetAppointmentsByDateResponse': TypeInfo(TypeOf.Class, create:() => GetAppointmentsByDateResponse()),
    'List<Order>': TypeInfo(TypeOf.Class, create:() => <Order>[]),
    'GetAppointmentsByDate': TypeInfo(TypeOf.Class, create:() => GetAppointmentsByDate()),
});

Dart GetAppointmentsByDate DTOs

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

To embed the response in a jsonp callback, append ?callback=myCallback

HTTP + JSON

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

GET /WebApp/Appointments/ByDate/{FromDate} HTTP/1.1 
Host: immo-account-servamw.eras-online.de 
Accept: application/json

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

{"totalNutzeinheiten":0,"completedNutzeinheiten":0,"totalDevices":0,"completedDevices":0,"responseStatus":{"errorCode":"String","message":"String","stackTrace":"String","errors":[{"errorCode":"String","fieldName":"String","message":"String","meta":{"String":"String"}}],"meta":{"String":"String"}},"amwInfoKeyNutzeinheiten":0,"amwInfoKeyDevices":0}