Server

<back to all web services

GetAppointment

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

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

// @DataContract
class Abrechnungseinheit implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="Objektnummer")
    String? Objektnummer;

    // @DataMember(Name="Anmerkung")
    String? Anmerkung;

    // @DataMember(Name="Address")
    Address? Address;

    Abrechnungseinheit({this.Guid,this.Objektnummer,this.Anmerkung,this.Address});
    Abrechnungseinheit.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        Objektnummer = json['number'];
        Anmerkung = json['note'];
        Address = JsonConverters.fromJson(json['address'],'Address',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'objektnummer': Objektnummer,
        'anmerkung': Anmerkung,
        'address': JsonConverters.toJson(Address,'Address',context!)
    };

    getTypeName() => "Abrechnungseinheit";
    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;
}

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

class Order implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="Abrechnungseinheit")
    Abrechnungseinheit? Abrechnungseinheit;

    // @DataMember(Name="AuftragNummer")
    String? AuftragNummer;

    // @DataMember(Name="Bezeichnung")
    String? Bezeichnung;

    // @DataMember(Name="Anmerkung")
    String? Anmerkung;

    // @DataMember(Name="Termine")
    List<Appointment>? Termine;

    // @DataMember(Name="AuftragZustand")
    OrderState? AuftragZustand;

    Order({this.Guid,this.Abrechnungseinheit,this.AuftragNummer,this.Bezeichnung,this.Anmerkung,this.Termine,this.AuftragZustand});
    Order.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        Abrechnungseinheit = JsonConverters.fromJson(json['abrechnungseinheit'],'Abrechnungseinheit',context!);
        AuftragNummer = json['number'];
        Bezeichnung = json['label'];
        Anmerkung = json['note'];
        Termine = JsonConverters.fromJson(json['appointments'],'List<Appointment>',context!);
        AuftragZustand = JsonConverters.fromJson(json['orderState'],'OrderState',context!);
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'abrechnungseinheit': JsonConverters.toJson(Abrechnungseinheit,'Abrechnungseinheit',context!),
        'auftragNummer': AuftragNummer,
        'bezeichnung': Bezeichnung,
        'anmerkung': Anmerkung,
        'termine': JsonConverters.toJson(Termine,'List<Appointment>',context!),
        'auftragZustand': JsonConverters.toJson(AuftragZustand,'OrderState',context!)
    };

    getTypeName() => "Order";
    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;
}

class GetAppointmentResponse implements IConvertible
{
    Order? order;
    List<DeviceOrderState>? backDeviceStates;
    ResponseStatus? responseStatus;

    GetAppointmentResponse({this.order,this.backDeviceStates,this.responseStatus});
    GetAppointmentResponse.fromJson(Map<String, dynamic> json) { fromMap(json); }

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

    Map<String, dynamic> toJson() => {
        'order': JsonConverters.toJson(order,'Order',context!),
        'backDeviceStates': JsonConverters.toJson(backDeviceStates,'List<DeviceOrderState>',context!),
        'responseStatus': JsonConverters.toJson(responseStatus,'ResponseStatus',context!)
    };

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

// @DataContract
class GetAppointment implements IConvertible
{
    // @DataMember(Name="Guid")
    String? Guid;

    // @DataMember(Name="AllAppointments")
    bool? AllAppointments;

    GetAppointment({this.Guid,this.AllAppointments});
    GetAppointment.fromJson(Map<String, dynamic> json) { fromMap(json); }

    fromMap(Map<String, dynamic> json) {
        Guid = json['guid'];
        AllAppointments = json['allAppointments'];
        return this;
    }

    Map<String, dynamic> toJson() => {
        'guid': Guid,
        'allAppointments': AllAppointments
    };

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

TypeContext _ctx = TypeContext(library: 'inea_servamw.eras_online.de', types: <String, TypeInfo> {
    'Address': TypeInfo(TypeOf.Class, create:() => Address()),
    'Abrechnungseinheit': TypeInfo(TypeOf.Class, create:() => Abrechnungseinheit()),
    '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>[]),
    '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()),
    'Order': TypeInfo(TypeOf.Class, create:() => Order()),
    'List<Appointment>': TypeInfo(TypeOf.Class, create:() => <Appointment>[]),
    'DeviceOrderKind': TypeInfo(TypeOf.Enum, enumValues:DeviceOrderKind.values),
    'DeviceOrderState': TypeInfo(TypeOf.Class, create:() => DeviceOrderState()),
    'GetAppointmentResponse': TypeInfo(TypeOf.Class, create:() => GetAppointmentResponse()),
    'List<DeviceOrderState>': TypeInfo(TypeOf.Class, create:() => <DeviceOrderState>[]),
    'GetAppointment': TypeInfo(TypeOf.Class, create:() => GetAppointment()),
});

Dart GetAppointment DTOs

GET /Appointment/{Guid} HTTP/1.1 
Host: inea-servamw.eras-online.de 
Accept: application/xml

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

<GetAppointmentResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Eras2Amw.Service.Server.ServiceModel.Eras2Client.Order">
  <Appointment xmlns:d2p1="http://schemas.datacontract.org/2004/07/Eras2Amw.Service.Server.ServiceModel.Common">
    <d2p1:Bis>0001-01-01T00:00:00</d2p1:Bis>
    <d2p1:Guid>00000000-0000-0000-0000-000000000000</d2p1:Guid>
    <d2p1:Monteure i:nil="true" />
    <d2p1:Nutzeinheiten i:nil="true" />
    <d2p1:Von>0001-01-01T00:00:00</d2p1:Von>
  </Appointment>
  <ResponseStatus xmlns:d2p1="http://schemas.servicestack.net/types">
    <d2p1:ErrorCode>String</d2p1:ErrorCode>
    <d2p1:Message>String</d2p1:Message>
    <d2p1:StackTrace>String</d2p1:StackTrace>
    <d2p1:Errors>
      <d2p1:ResponseError>
        <d2p1:ErrorCode>String</d2p1:ErrorCode>
        <d2p1:FieldName>String</d2p1:FieldName>
        <d2p1:Message>String</d2p1:Message>
        <d2p1:Meta xmlns:d5p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
          <d5p1:KeyValueOfstringstring>
            <d5p1:Key>String</d5p1:Key>
            <d5p1:Value>String</d5p1:Value>
          </d5p1:KeyValueOfstringstring>
        </d2p1:Meta>
      </d2p1:ResponseError>
    </d2p1:Errors>
    <d2p1:Meta xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
      <d3p1:KeyValueOfstringstring>
        <d3p1:Key>String</d3p1:Key>
        <d3p1:Value>String</d3p1:Value>
      </d3p1:KeyValueOfstringstring>
    </d2p1:Meta>
  </ResponseStatus>
</GetAppointmentResponse>