Server

AddOrUpdateAbrechnungseinheit

The following routes are available for this service:
POST	/AddUpdateAbrechnungseinheit

import 'package:servicestack/servicestack.dart';

class AddOrUpdateAbrechnungseinheitResponse implements IConvertible
{
    ResponseStatus? responseStatus;

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

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

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

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

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

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

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

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

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

    Map<String, dynamic> toJson() => {
        'abrechnungseinheit': JsonConverters.toJson(Abrechnungseinheit,'Abrechnungseinheit',context!)
    };

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

TypeContext _ctx = TypeContext(library: 'inea_servamw.eras_online.de', types: <String, TypeInfo> {
    'AddOrUpdateAbrechnungseinheitResponse': TypeInfo(TypeOf.Class, create:() => AddOrUpdateAbrechnungseinheitResponse()),
    'Customer': TypeInfo(TypeOf.Class, create:() => Customer()),
    'Address': TypeInfo(TypeOf.Class, create:() => Address()),
    'PersonAbrechnungseinheit': TypeInfo(TypeOf.Class, create:() => PersonAbrechnungseinheit()),
    'PersonCommunication': TypeInfo(TypeOf.Class, create:() => PersonCommunication()),
    'Person': TypeInfo(TypeOf.Class, create:() => Person()),
    'List<PersonCommunication>': TypeInfo(TypeOf.Class, create:() => <PersonCommunication>[]),
    'Abrechnungseinheit': TypeInfo(TypeOf.Class, create:() => Abrechnungseinheit()),
    'List<PersonAbrechnungseinheit>': TypeInfo(TypeOf.Class, create:() => <PersonAbrechnungseinheit>[]),
    'List<Person>': TypeInfo(TypeOf.Class, create:() => <Person>[]),
    'AddOrUpdateAbrechnungseinheit': TypeInfo(TypeOf.Class, create:() => AddOrUpdateAbrechnungseinheit()),
});

Dart AddOrUpdateAbrechnungseinheit DTOs

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

HTTP + XML

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

POST /AddUpdateAbrechnungseinheit HTTP/1.1 
Host: inea-servamw.eras-online.de 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<AddOrUpdateAbrechnungseinheit xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Eras2Amw.Service.Server.ServiceModel.Eras2Client.Business">
  <Abrechnungseinheit xmlns:d2p1="http://schemas.datacontract.org/2004/07/Eras2Amw.Service.Server.ServiceModel.Common">
    <d2p1:Address>
      <d2p1:Adresszusatz>String</d2p1:Adresszusatz>
      <d2p1:Breitengrad>0</d2p1:Breitengrad>
      <d2p1:Guid>00000000-0000-0000-0000-000000000000</d2p1:Guid>
      <d2p1:Hausnummer>String</d2p1:Hausnummer>
      <d2p1:Laengengrad>0</d2p1:Laengengrad>
      <d2p1:Ort>String</d2p1:Ort>
      <d2p1:Postfach>String</d2p1:Postfach>
      <d2p1:Postleitzahl>String</d2p1:Postleitzahl>
      <d2p1:Straße>String</d2p1:Straße>
      <d2p1:Straße2>String</d2p1:Straße2>
    </d2p1:Address>
    <d2p1:BilligPeriodEnd>0001-01-01T00:00:00</d2p1:BilligPeriodEnd>
    <d2p1:Customer>
      <d2p1:Anrede>String</d2p1:Anrede>
      <d2p1:Guid>00000000-0000-0000-0000-000000000000</d2p1:Guid>
      <d2p1:Kundennummer>String</d2p1:Kundennummer>
      <d2p1:Name>String</d2p1:Name>
      <d2p1:Name2>String</d2p1:Name2>
      <d2p1:Name3>String</d2p1:Name3>
      <d2p1:Notiz>String</d2p1:Notiz>
    </d2p1:Customer>
    <d2p1:Guid>00000000-0000-0000-0000-000000000000</d2p1:Guid>
    <d2p1:LastModified>0001-01-01T00:00:00</d2p1:LastModified>
    <d2p1:Note>String</d2p1:Note>
    <d2p1:NoteInternal>String</d2p1:NoteInternal>
    <d2p1:NoteLegionella>String</d2p1:NoteLegionella>
    <d2p1:Number>String</d2p1:Number>
    <d2p1:PersonAbrechnungseinheiten i:nil="true" />
    <d2p1:Persons i:nil="true" />
  </Abrechnungseinheit>
</AddOrUpdateAbrechnungseinheit>

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

<AddOrUpdateAbrechnungseinheitResponse xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Eras2Amw.Service.Server.ServiceModel.Eras2Client.Business">
  <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>
</AddOrUpdateAbrechnungseinheitResponse>