Server

UpdateAbrechnungseinheit

The following routes are available for this service:
PUT	/App/{UserId}/Abrechnungseinheit

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

class UpdateAbrechnungseinheitResponse implements IConvertible
{
    ResponseStatus? responseStatus;

    UpdateAbrechnungseinheitResponse({this.responseStatus});
    UpdateAbrechnungseinheitResponse.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() => "UpdateAbrechnungseinheitResponse";
    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 UpdateAbrechnungseinheit extends Eras2AppServiceModelBase implements IConvertible
{
    // @DataMember(Name="Abrechnungseinheit")
    Abrechnungseinheit? Abrechnungseinheit;

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

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

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

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

TypeContext _ctx = TypeContext(library: 'marneth_messdienst_servamw.eras_online.de', types: <String, TypeInfo> {
    'Eras2AppServiceModelBase': TypeInfo(TypeOf.AbstractClass),
    'UpdateAbrechnungseinheitResponse': TypeInfo(TypeOf.Class, create:() => UpdateAbrechnungseinheitResponse()),
    '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>[]),
    'UpdateAbrechnungseinheit': TypeInfo(TypeOf.Class, create:() => UpdateAbrechnungseinheit()),
});

Dart UpdateAbrechnungseinheit DTOs

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

HTTP + JSV

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

PUT /App/{UserId}/Abrechnungseinheit HTTP/1.1 
Host: marneth-messdienst-servamw.eras-online.de 
Accept: text/jsv
Content-Type: text/jsv
Content-Length: length

{
	Abrechnungseinheit: 
	{
		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
	},
	UserId: 00000000000000000000000000000000
}

HTTP/1.1 200 OK
Content-Type: text/jsv
Content-Length: length

{
	responseStatus: 
	{
		errorCode: String,
		message: String,
		stackTrace: String,
		errors: 
		[
			{
				errorCode: String,
				fieldName: String,
				message: String,
				meta: 
				{
					String: String
				}
			}
		],
		meta: 
		{
			String: String
		}
	}
}