com

Documentation

Index

• func AdresseStructLevelValidation(sl validator.StructLevel)
• type Adresse
• type Dienstleistung
• type ExterneReferenz
• type Geokoordinaten
• type Hardware
• type Katasteradresse
• type Menge
• type Unterschrift
• type Verbrauch
• type Vertragskonditionen
• type Vertragsteil
• type Zaehlerstaende
  • func (z Zaehlerstaende) Len() int
  • func (z Zaehlerstaende) Less(i, j int) bool
  • func (z Zaehlerstaende) Swap(i, j int)
• type Zaehlerstand
• type Zaehlwerk
• type Zeitraum
• type Zeitreihenwert
• type Zeitreihenwertkompakt

Functions

func AdresseStructLevelValidation

func AdresseStructLevelValidation(sl validator.StructLevel)

AdresseStructLevelValidation does a cross check on a Adresse object

Types

type Adresse

type Adresse struct {
	Postleitzahl string                `json:"postleitzahl,omitempty" example:"82031" validate:"numeric,required"` // zip code, mandatory
	Ort          string                `json:"ort,omitempty" example:"Grünwald" validate:"alphaunicode,required"`  // city name, mandatory
	Strasse      string                `json:"strasse,omitempty" example:"Nördliche Münchner Straße 27A"`          // street name
	Hausnummer   string                `json:"hausnummer,omitempty" example:"27A"`                                 // house number including suffixes like "a" or "-1"
	Postfach     string                `json:"postfach,omitempty"`                                                 // post box
	Adresszusatz string                `json:"adresszusatz,omitempty" example:"3. Stock linke Wohnung"`            // additional data, like f.e. floor or "Hinterhaus"
	CoErgaenzung string                `json:"co_ergaenzung,omitempty" example:"c/o Veronica Hauptmieterin"`       //
	Landescode   landescode.Landescode `json:"landescode,omitempty"`                                               // ISO 3166 country code
}

Adresse is a general purpose address struct

type Dienstleistung

type Dienstleistung struct {
	DienstleistungsTyp dienstleistung.Dienstleistungstyp `json:"dienstleistungstyp" validate:"required"`       // type of the service
	Bezeichnung        string                            `json:"bezeichnung" validate:"alphaunicode,required"` // description
}

A Dienstleistung is a billable Service

type ExterneReferenz

type ExterneReferenz struct {
	ExRefName string `json:"exRefName" validate:"required"` // Name of the external reference (e.g. "SAP IS-U" or "BelVis ID"
	ExRefWert string `json:"exRefWert" validate:"required"` // Value of the external reference, usually a unique value
}

ExterneReferenz models the existence of an object in another system and defines a way to reference it there

type Geokoordinaten

type Geokoordinaten struct {
	Breitengrad float32 `json:"breitengrad" validate:"latitude"`  // latitude
	Laengengrad float32 `json:"laengengrad" validate:"longitude"` // longitude
}

Geokoordinaten are GPS coordinates

type Hardware

type Hardware struct {
	GeraeteTyp  geraetetyp.Geraetetyp `json:"geraeteTyp" validate:"required"`               // type of the hardware
	Bezeichnung string                `json:"bezeichnung" validate:"alphaunicode,required"` // description
}

A Hardware is a billable device

type Katasteradresse

type Katasteradresse struct {
	// ToDo: why is this `gemarkung_flur` and not `gemarkungFlur`
	GemarkungFlur string `json:"gemarkung_flur" validate:"required"` // the district in which something is located
	Flurstueck    string `json:"flurstueck" validate:"required"`     // parcel
}

Katasteradresse is a cadastre location

type Menge

type Menge struct {
	Wert    float32                     `json:"wert" validate:"omitempty,required"` //Gibt den absoluten Wert der Menge an
	Einheit mengeneinheit.Mengeneinheit `json:"einheit" validate:"required"`        //Gibt die Einheit zum jeweiligen Wert an
}

Menge ist die Abbildung einer Menge mit Wert und Einheit.

type Unterschrift

type Unterschrift struct {
	Name  string    `json:"name" validate:"required"`   // Name des Unterschreibers
	Datum time.Time `json:"datum" validate:"omitempty"` // Datum der Unterschrift
	Ort   string    `json:"ort" validate:"omitempty"`   // Ort, an dem die Unterschrift geleistet wird
}

Unterschrift ist die Modellierung einer Unterschrift, z.B. für Verträge, Angebote etc.

type Verbrauch

type Verbrauch struct {
	Startdatum               time.Time                                         `json:"startdatum" validate:"omitempty"`                      // inclusive start
	Enddatum                 time.Time                                         `json:"enddatum" validate:"omitempty,gtfield=Startdatum"`     // exclusive end
	Wertermittlungsverfahren wertermittlungsverfahren.Wertermittlungsverfahren `json:"wertermittlungsverfahren" validate:"required"`         // type of the consumption
	Obiskennzahl             string                                            `json:"obiskennzahl" validate:"required" example:"1-0:1.8.1"` // OBIS Kennzahl // (?<power>(1)-((?:[0-5]?[0-9])|(?:6[0-5])):((?:[1-8]|99))\.((?:6|8|9|29))\.([0-9]{1,2}))||(?<gas>)(7)-((?:[0-5]?[0-9])|(?:6[0-5])):(.{1,2})\.(.{1,2})\.([0-9]{1,2})
	Wert                     float32                                           `json:"wert" validate:"required" example:"17"`                // value (of einheit)
	Einheit                  mengeneinheit.Mengeneinheit                       `json:"einheit" validate:"required" example:"KWH"`            // unit (associated to the wert)
}

Verbrauch is a a consumption during a specific time frame

type Vertragskonditionen

type Vertragskonditionen struct {
	Beschreibung          string   `json:"beschreibung,omitempty"`          // Freitext zur Beschreibung der Konditionen, z.B. "Standardkonditionen Gas"
	AnzahlAbschlaege      int      `json:"anzahlAbschlaege,omitempty"`      // Anzahl der vereinbarten Abschläge pro Jahr, z.B. 12
	Vertragslaufzeit      Zeitraum `json:"vertragslaufzeit,omitempty"`      // 	Über diesen Zeitraum läuft der Vertrag.
	Kuendigungsfrist      Zeitraum `json:"kuendigungsfrist,omitempty"`      // 	Innerhalb dieser Frist kann der Vertrag gekündigt werden.
	Vertragsverlaengerung Zeitraum `json:"vertragsverlaengerung,omitempty"` //  Falls der Vertrag nicht gekündigt wird, verlängert er sich automatisch um die hier angegebene Zeit.
	Abschlagszyklus       Zeitraum `json:"abschlagszyklus,omitempty"`       //	In diesen Zyklen werden Abschläge gestellt. Alternativ kann auch die Anzahl in den Konditionen angeben werden.
}

Vertragskonditionen ist eine Komponente zur Abbildung von Vertragskonditionen. Die Komponente wird sowohl im Vertrag als auch im Tarif verwendet.

type Vertragsteil

type Vertragsteil struct {
	Vertragsteilbeginn       time.Time `json:"vertragsteilbeginn" validate:"required"`                          // Start der Gültigkeit des Vertragsteils.
	Vertragsteilende         time.Time `json:"Vertragsteilende" validate:"required,gtfield=Vertragsteilbeginn"` // Ende der Gültigkeit des Vertragsteils.
	Lokation                 string    `json:"lokation" validate:"omitempty,alphanum,min=11,max=33"`            // Der Identifier für diejenigen Markt- oder Messlokation, die zu diesem Vertragsteil gehören. Verträge für mehrere Lokationen werden mit mehreren Vertragsteilen abgebildet.
	VertraglichFixierteMenge *Menge    `json:"vertraglichFixierteMenge"`                                        // Für die Lokation festgeschriebene Abnahmemenge
	MinimaleAbnahmemenge     *Menge    `json:"minimaleAbnahmemenge"`                                            // Für die Lokation festgelegte Mindestabnahmemenge
	MaximaleAbnahmemenge     *Menge    `json:"maximaleAbnahmemenge"`                                            // Für die Lokation festgelegte maximale Abnahmemenge
}

Vertragsteil wird dazu verwendet, eine vertragliche Leistung in Bezug zu einer Lokation (Markt- oder Messlokation) festzulegen.

type Zaehlerstaende

type Zaehlerstaende []Zaehlerstand

Zaehlerstaende is a table type of Zaehlerstand with defined descending sorting of the Zaehlerstand.Ablesedatum for sort.Sort(...)

func (Zaehlerstaende) Len

func (z Zaehlerstaende) Len() int

Len returns the size of z

func (Zaehlerstaende) Less

func (z Zaehlerstaende) Less(i, j int) bool

Less returns true iff the Zaehlerstand.Ablesedatum at index i is after the Zaehlerstand.Ablesedatum at index j

func (Zaehlerstaende) Swap

func (z Zaehlerstaende) Swap(i, j int)

Swap swaps the entries at index i and j

type Zaehlerstand

type Zaehlerstand struct {
	Ablesedatum              time.Time                                         `json:"ablesedatum" validate:"required"`              // point in time
	Wertermittlungsverfahren wertermittlungsverfahren.Wertermittlungsverfahren `json:"wertermittlungsverfahren" validate:"required"` // type of the consumption
	Wert                     float32                                           `json:"wert" validate:"required" example:"17086"`     // value (of einheit)
	Einheit                  mengeneinheit.Mengeneinheit                       `json:"einheit" validate:"required" example:"KWH"`    // unit (associated to the wert)
	Brennwert                float32                                           `json:"brennwert,omitempty"`                          // used to calculate caloric Energy from gas volume
	Zustandszahl             float32                                           `json:"zustandszahl,omitempty"`                       // used to calculate caloric Energy from gas volume
}

Zaehlerstand is the value of a meter for a specific point in time

type Zaehlwerk

type Zaehlwerk struct {
	ZaehlwerkId    string                          `json:"zaehlwerkId" validate:"required" example:"47110815_1"`          // Identifikation des Zählwerks (Registers) innerhalb des Zählers. Oftmals eine laufende Nummer hinter der Zählernummer.
	Bezeichnung    string                          `json:"bezeichnung" validate:"required" example:"Zählwerk_Wirkarbeit"` // Zusätzliche Bezeichnung
	Richtung       energierichtung.Energierichtung `json:"richtung" validate:"required"`                                  // Die Energierichtung, Einspeisung oder Ausspeisung.
	ObisKennzahl   string                          `json:"obisKennzahl" validate:"required" example:"1-0:1.8.1"`          // Die OBIS-Kennzahl für das Zählwerk, die festlegt, welche auf die gemessene Größe mit dem Stand gemeldet wird. Nur Zählwerkstände mit dieser OBIS-Kennzahl werden an diesem Zählwerk registriert.
	Wandlerfaktor  float32                         `json:"wandlerfaktor" validate:"required"`                             // Mit diesem Faktor wird eine Zählerstandsdifferenz multipliziert, um zum eigentlichen Verbrauch im Zeitraum zu kommen.
	Einheit        mengeneinheit.Mengeneinheit     `json:"einheit" validate:"required"`                                   // Die Einheit der gemessenen Größe
	Zaehlerstaende Zaehlerstaende                  `json:"zaehlerstaende,omitempty"`                                      // Non BO4E Standard
}

A Zaehlwerk is the counting part of a meter. A meter consists of one or more Zaehlwerke

type Zeitraum

type Zeitraum struct {
	Einheit        zeiteinheit.Zeiteinheit `json:"zeiteinheit,omitempty" validate:"omitempty,required_with=Dauer"`                                          // unit of measurement
	Dauer          float32                 `json:"dauer,omitempty" validate:"omitempty,required_with=Einheit"`                                              // duration
	Startzeitpunkt time.Time               `json:"startzeitpunkt,omitempty" validate:"required_without_all=Einheit Dauer" example:"2018-01-28T10:15:00+01"` // inclusive begin
	Endzeitpunkt   time.Time               ``                                                                                                               // exclusive end
	/* 135-byte string literal not displayed */
}

Zeitraum ist eine Komponente zur Abbildung von Zeiträumen in Form von Dauern oder der Angabe von Start und Ende verwendet.

type Zeitreihenwert

type Zeitreihenwert struct {
	Zeitreihenwertkompakt
	DatumUhrzeitVon time.Time `json:"datumUhrzeitVon" validate:"required" example:"2018-01-28T10:15:00+01"` // inclusive begin
	DatumUhrzeitBis time.Time `json:"datumUhrzeitBis" validate:"required" example:"2018-01-28T10:30:00+01"` // exclusive end
}

Zeitreihenwert ist eine Abbildung eines Zeitreihenwertes bestehend aus Zeitraum, Wert und Statusinformationen.

type Zeitreihenwertkompakt

type Zeitreihenwertkompakt struct {
	Wert         float32                                   `json:"wert" validate:"required" example:"17"` // 	Der im Zeitintervall gültige Wert.
	Status       messwertstatus.Messwertstatus             `json:"status,omitempty"`                      // Der Status gibt an, wie der Wert zu interpretieren ist, z.B. in Berechnungen.
	Statuszusatz messwertstatuszusatz.Messwertstatuszusatz `json:"statuszusatz,omitempty"`                // Eine Zusatzinformation zum Status, beispielsweise ein Grund für einen fehlenden Wert.
}

Zeitreihenwertkompakt ist eine Abbildung eines kompakten Zeitreihenwertes in dem ausschliesslich der Wert und Statusinformationen stehen.