diff --git a/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go b/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go
index 4816e95bf1fe4d55bd873e935c82be67f96e469b..7c27be411c999d5fee3971ac3c36309581ac55c9 100644
--- a/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go
+++ b/applications/inventory-manager-netbox/inventoryManager/inventoryManager.go
@@ -1,21 +1,23 @@
-package inventorymanager
+package inventoryManager
 
 import (
 	"context"
+	"flag"
 	"log"
+	"os"
 	"time"
 
+	//	"code.fbi.h-da.de/danet/gosdn/controller/api"
+
+	"code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement"
 	"code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/config"
-	"github.com/netbox-community/go-netbox/netbox"
-	"github.com/netbox-community/go-netbox/netbox/client"
-	"github.com/netbox-community/go-netbox/netbox/client/extras"
-	"github.com/netbox-community/go-netbox/netbox/models"
+	"code.fbi.h-da.de/danet/gosdn/controller/api"
+
+	//inventorymanager "code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/inventoryManager"
 	"github.com/sirupsen/logrus"
 	"google.golang.org/grpc"
 	"google.golang.org/grpc/credentials/insecure"
-	//"github.com/smutel/go-netbox/netbox/client"
-	//"github.com/smutel/go-netbox/netbox/client/extras"
-	//"github.com/smutel/go-netbox/netbox/models"
+	"gopkg.in/yaml.v3"
 )
 
 type InventoryManager struct {
@@ -26,18 +28,44 @@ type InventoryManager struct {
 	sessionToken      string
 }
 
-type NetboxManager struct {
-	NetboxConfig *config.NetboxConfig
-}
+// createGosdnConnectionwitNetzworkElementslist creates a context with the given authorization token. And gives the list of network elements bag.
+func CreateGosdnConnectionwitNetzworkElementslist() (*networkelement.GetAllResponse, error) {
+	// Configpfad aus CLI-Flag holen
+	configFile := flag.String("configGosdn", "config/config.yaml", "Pfad zur NetBox-Konfigurationsdatei")
+	flag.Parse()
 
-// Hilfsfunktion
-func Int64Ptr(i int64) *int64 {
-	return &i
-}
+	log.Printf("Config-Pfad: %s", *configFile)
+
+	//Reading the config file
+	data, err := os.ReadFile(*configFile)
+	if err != nil {
+		log.Printf("Fehler beim Lesen der Konfigurationsdatei: %v", err)
+		return nil, err
+	}
+
+	// YAML in Config-Struct einlesen
+	gosdnConfig := &config.Config{}
+	if err := yaml.Unmarshal(data, gosdnConfig); err != nil {
+		log.Printf("Fehler beim Parsen der YAML-Datei: %v", err)
+		return nil, err
+	}
+	/*
+		log.Printf("gosdn Config AppName: %v", gosdnConfig.AppName)
+		log.Printf("gosdn Config ControllerAddress: %v", gosdnConfig.ControllerAddress)
+		log.Printf("gosdn Config PndID: %v", gosdnConfig.PndID)
+		log.Printf("gosdn Config UserName: %v", gosdnConfig.UserName)
+		log.Printf("Config Config UserPW: %v", gosdnConfig.UserPW)
+	*/
+	invManager, err := InitializeInventoryManager(gosdnConfig)
+	if err != nil {
+		log.Fatal(err)
+	}
+	//log.Print(invManager) //i dont know what this is
+
+	//gibt die Liste mit geräte vom Controller aus.
+	elements := listRunningNetworkElements(invManager)
 
-// String in einen *string zu konvertieren
-func StringPtrr(s string) *string {
-	return &s
+	return elements, nil
 }
 
 // InitializeInventoryManager sets up the inventory manager and logs in to the controller.
@@ -74,125 +102,37 @@ func InitializeInventoryManager(config *config.Config) (*InventoryManager, error
 func NewInventoryManager(grpcClientConn *grpc.ClientConn, sessionToken, controllerAddress, pndID, appName string) (*InventoryManager, error) {
 	ctx := createContextWithAuthorization(sessionToken)
 
-	// Not needed now, but later when lifecycle is implemented
-	//queueCredentials, err := getQueueCredentials(ctx, controllerAddress, appName, registrationToken)
-	//if err != nil {
-	//	return nil, err
-	//}
-	//
-	//eventService, err := event.NewEventService(
-	//	queueCredentials,
-	//	[]event.Topic{event.ManagedNetworkElement},
-	//)
-	//if err != nil {
-	//	return nil, err
-	//}
-
 	return &InventoryManager{
-		grpcClientConn: grpcClientConn,
-		sessionContext: ctx,
-		sessionToken:   sessionToken,
-		//eventService:          eventService,
+		grpcClientConn:    grpcClientConn,
+		sessionContext:    ctx,
+		sessionToken:      sessionToken,
 		pndID:             pndID,
 		controllerAddress: controllerAddress,
 	}, nil
 }
 
-// Run starts the InventoryManager. This will elad to it trying to create every network element from the config file.
-// It will try to create it indefinitely.
-// TODO: After creating a network element, it will ensure that the element exists in the controller.
-func (i *InventoryManager) Run() error {
-	//i.createNetworkelements()
-
-	return nil
-}
-
-func (i *InventoryManager) createNetworkelements() {
-
-	//Hier einmal alles rausgeworfen. Nutze ich dan nauch wieder. bloß gerade nicht^^
-
-	//err = api.AddNetworkElement(i.sessionContext, i.controllerAddress, networkElement.Name, networkElement.UUID, &transportOptions, pluginUUID, pndUUID, []string{})
-	// err = api.AddNetworkElement("test", "test", "test", "test", "test", "test", "test", []string{})
-
-}
-
-// Funktion zur Initialisierung des NetBox Clients
-/*
-func (i *NetboxManager) initializeNetboxClient() *client.NetBoxAPI {
-	return netbox.NewNetboxWithAPIKey(i.NetboxConfig.NetboxAddress, i.NetboxConfig.ApiToken)
-}
+// listRunningNetworkElements takes on an InventoryManager instance and retrieves the currently running network elements from the controller, returning them.
+func listRunningNetworkElements(i *InventoryManager) *networkelement.GetAllResponse {
 
-func (i *NetboxManager) initializeNetboxClient() *netbox.NetBox {
-	return netbox.NewNetboxWithAPIKey(i.NetboxConfig.NetboxAddress, i.NetboxConfig.ApiToken)
-}
-*/
-
-// Funktion zur Erstellung eines neuen WirelessLAN Modells
-/*
-func createNewWirelessLAN(ssid, status, comments, description string, vlanID int64) *models.WritableWirelessLAN {
-	return &models.WritableWirelessLAN{
-		Ssid:        StringPtrr(ssid),
-		Status:      status,
-		Comments:    comments,
-		Description: description,
-		Vlan:        Int64Ptr(vlanID),
-	}
-}
-*/
-
-func createNewWirelessLAN(ssid, status, comments, description string, vlanID int64) *models.WritableWirelessLAN {
-	return &models.WritableWirelessLAN{
-		Ssid:        StringPtrr(ssid),
-		Status:      status,
-		Comments:    comments,
-		Description: description,
-		Vlan:        Int64Ptr(vlanID),
-	}
-}
-
-// Funktion zur Erstellung eines neuen Tags (mit einer korrekten Methode)
-func CreateNewTag() *models.Tag {
-	return &models.Tag{
-		Name:        StringPtrr("Guter Tag aus dem richtigen Programm"),
-		Slug:        StringPtrr("guter-tag6"),
-		Description: "Das ist ein gutes Gerät, aus dem richtigen Programm",
-	}
-}
-
-// Funktion zur Durchführung des API-Requests für Tags (mit richtiger Methode)
-func CreateTag(c *client.NetBoxAPI, newTag *models.Tag, ctx context.Context) (*models.Tag, error) {
-	req := extras.NewExtrasTagsCreateParamsWithContext(ctx) // Tags-API unter extras
-	req.SetData(newTag)
-
-	res, err := c.Extras.ExtrasTagsCreate(req, nil) // Verwende die korrekte Methode
+	elements, err := api.GetNetworkElements(i.sessionContext, i.controllerAddress, i.pndID)
 	if err != nil {
-		return nil, err
+		logrus.Errorf("Fehler beim Abrufen der Netzwerkelemente: %s", err.Error())
+		return nil
 	}
-
-	return res.Payload, nil
-}
-
-func (i *NetboxManager) Run() error {
-	i.createNetboxConnection()
-
-	//logrus.Info("Netbox-Verbindung aufbauen mit Adresse:", i.NetboxConfig.NetboxAddress)
-	//logrus.Info("Connecting and logging in to controller ", i.NetboxConfig.ApiToken)
-	return nil
-}
-
-func (i *NetboxManager) createNetboxConnection() {
-	ctx := context.Background()
-	client := netbox.NewNetboxWithAPIKey(i.NetboxConfig.NetboxAddress, i.NetboxConfig.ApiToken)
-
-	//client := i.initializeNetboxClient()
-	//logrus.Info("Netbox-Verbindung aufbauen mit Adresse:", i.NetboxConfig.NetboxAddress)
-	//logrus.Info("Connecting and logging in to controller ", i.NetboxConfig.ApiToken)
-
-	newTag := CreateNewTag()
-	createdTag, err := CreateTag(client, newTag, ctx)
-	if err != nil {
-		log.Fatalf("Fehler beim Erstellen des Tags: %v", err)
-	}
-	log.Printf("Neues Tag erstellt: %v", createdTag)
-
+	/*
+		// Debugging
+		logrus.Info("Abrufen der laufenden Netzwerkelemente...")
+		logrus.Infof("sessionContext Print %s", i.sessionContext)
+		logrus.Infof("controllerAddress Print %s", i.controllerAddress)
+		logrus.Infof("pndID Print %s", i.pndID)
+
+		// Netzwerkelemente ausgeben
+		logrus.Info("Gefundene Netzwerkelemente:")
+		for _, element := range elements.Mne {
+			logrus.Info("element.Name: ", element.Name)
+			logrus.Info("element.Id: ", element.Id)
+			logrus.Info("element.Plugin: ", element.Plugin)
+		}
+	*/
+	return elements
 }
diff --git a/applications/inventory-manager-netbox/inventoryManager/netboxManager.go b/applications/inventory-manager-netbox/inventoryManager/netboxManager.go
deleted file mode 100644
index 87cb040bf5b6112281f043a92cd617ca4d66bc12..0000000000000000000000000000000000000000
--- a/applications/inventory-manager-netbox/inventoryManager/netboxManager.go
+++ /dev/null
@@ -1 +0,0 @@
-package inventorymanager
diff --git a/applications/inventory-manager-netbox/main.go b/applications/inventory-manager-netbox/main.go
index 961c1a0a611c20d0644bf2d6b23aa9a2a5931544..6d8ee5fca8cf720723ceb0119ba000a5e073a7af 100644
--- a/applications/inventory-manager-netbox/main.go
+++ b/applications/inventory-manager-netbox/main.go
@@ -1,112 +1,67 @@
 package main
 
 import (
-	"flag"
 	"log"
-	"os"
+	"time"
 
-	"code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/config"
-	inventorymanager "code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/inventoryManager"
-	"github.com/sirupsen/logrus"
-	"google.golang.org/grpc/resolver"
-	"gopkg.in/yaml.v3"
+	"code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement"
+	"code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/netboxManager"
 )
 
 func main() {
-	configFileController := flag.String("config", "config/config.yaml", "app config file")
-	configFileNetbox := flag.String("configNetbox", "config/configNetbox.yaml", "app config file")
-	logLevel := flag.String("log", "info", "logrus lof level (debug, info, warn, error, fatal, panic)")
-	noGRPCPassthrough := flag.Bool("noGRPCPassthrough", false, "set the default resolve scheme for grpc to not use  passthrough, default is false")
 
-	flag.Parse()
+	for {
+		var elementeFigure int
+		var elements *networkelement.GetAllResponse
+		var err error
 
-	if *noGRPCPassthrough {
-		logrus.Info("gRPC default resolver scheme is not set to passthrough. This might cause issues with the gRPC connection when no real DNS server is available as each gRPC requests requires a DNS request.")
-	} else {
-		logrus.Info("Setting gRPC default resolver scheme to passthrough. No DNS queries are being made when doing a gRPC request.")
-		resolver.SetDefaultScheme("passthrough")
-	}
-
-	// parse string, this is built-in feature of logrus
-	ll, err := logrus.ParseLevel(*logLevel)
-	if err != nil {
-		ll = logrus.InfoLevel
-		logrus.Warn("invalid log level, using default: ", ll)
-	}
-
-	// set global log level
-	logrus.Info("setting log level to ", ll)
-	logrus.SetLevel(ll)
-
-	logrus.Debugf("current config path: %s", *configFileController)
-	file, err := os.ReadFile(*configFileController)
-	if err != nil {
-		currentFolder, _ := os.Getwd()
-		log.Fatalf("error reading config file: %s, current folder: %s", *configFileController, currentFolder)
-	}
-
-	appConfig := &config.Config{}
-	if err = yaml.Unmarshal(file, appConfig); err != nil {
-		logrus.Fatal(err)
-	}
-
-	// Just for printing the config
-	configBytes, err := yaml.Marshal(appConfig)
-	if err != nil {
-		logrus.Fatal("error marshaling config to YAML: ", err)
-	}
-	logrus.Debugf("config:\n%s", string(configBytes))
-
-	inventoryManager, err := inventorymanager.InitializeInventoryManager(appConfig)
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	//Netbox Config File
-	logrus.Debugf("current config path: %s", *configFileNetbox)
-	filee, err := os.ReadFile(*configFileNetbox)
-	if err != nil {
-		currentFolder, _ := os.Getwd()
-		log.Fatalf("error reading config filee: %s, current folder: %s", *configFileNetbox, currentFolder)
-	}
+		//getting date from the controller.
+		elements, err = inventoryManager.CreateGosdnConnectionwitNetzworkElementslist()
+		if err != nil {
+			log.Fatalf("Fehler beim Erstellen der Controller Conenction: %v", err)
+		} else {
+			log.Println("Es ist alles cool!")
+		}
 
-	netboxconfig := &config.NetboxConfig{}
-	if err = yaml.Unmarshal(filee, netboxconfig); err != nil {
-		logrus.Fatal(err)
-	}
-	// Just for printing the config
-	configBytesNetbox, err := yaml.Marshal(netboxconfig)
-	if err != nil {
-		logrus.Fatal("error marshaling config to YAML: ", err)
+		//if elements != nil {
+		if len(elements.Mne) != elementeFigure {
+			//log.Printf("Es wurden %d Elemente gefunden", len(elementss.Mne))
+			//take the date into Netbox
+			err = netboxManager.FeedNetbox(elements)
+			if err != nil {
+				log.Fatalf("Fehler beim Erstellen des Geräts: %v", err)
+			} else {
+				log.Println("Es ist alles cool!")
+				elementeFigure = len(elements.Mne)
+				log.Printf("Es sind %d elementeFigur", elementeFigure)
+			}
+
+		} else {
+			log.Printf("Der Controller hat keine Daten für mich. Weiter machen Sinnlos^^ elements ist leer")
+			time.Sleep(1 * time.Second)
+		}
 	}
-	logrus.Debugf("config:\n%s", string(configBytesNetbox))
-
-	//logrus.Infof("Netbox Adresse: %s", netboxconfig.NetboxAddress)
-	//logrus.Infof("Controller Adresse: %s", appConfig.ControllerAddress)
 
 	/*
-		NetboxManager, err := inventorymanager.InitializeInventoryManager(netboxconfig)
+		elements, err := inventoryManager.CreateGosdnConnectionwitNetzworkElementslist()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatalf("Fehler beim Erstellen der Controller Conenction: %v", err)
+		} else {
+			log.Println("Es ist alles cool!")
 		}
-		err = NetboxManager.Run(netboxconfig)
+
+		err = netboxManager.Netboxmanager()
 		if err != nil {
-			logrus.Fatal(err)
+			log.Fatalf("Fehler beim Erstellen des Geräts: %v", err)
+		} else {
+			log.Println("Es ist alles cool!")
 		}
-	*/
-	//##############
-
-	err = inventoryManager.Run()
-	if err != nil {
-		logrus.Fatal(err)
-	}
-
-	netboxManager := &inventorymanager.NetboxManager{
-		NetboxConfig: netboxconfig,
-	}
 
-	err = netboxManager.Run()
-	if err != nil {
-		logrus.Fatal(err)
-	}
+		err = netboxManager.FeedNetbox(elementss)
+		if err != nil {
+			log.Fatalf("Fehler beim Erstellen des Geräts: %v", err)
+		} else {
+			log.Println("Es ist alles cool!")
+		}
+	*/
 }
diff --git a/applications/inventory-manager-netbox/netboxManager/netboxDinge.go b/applications/inventory-manager-netbox/netboxManager/netboxDinge.go
new file mode 100644
index 0000000000000000000000000000000000000000..f81ec9e2fe646a5d792a9ba9fa2898053f1b816f
--- /dev/null
+++ b/applications/inventory-manager-netbox/netboxManager/netboxDinge.go
@@ -0,0 +1,161 @@
+package netboxManager
+
+func createDevice() map[string]interface{} {
+	device := map[string]interface{}{
+		"name":        "Modulares-Gerät",
+		"device_type": 1,
+		"role":        1,
+		"site":        1,
+		"serial":      "SN123456999",
+		"description": "Kompaktes Beispielgerät",
+		"status":      "active",
+	}
+	return device
+}
+func createDeviceWithParameter(name, deviceTypeID, deviceRoleID, siteID, serial, description, status string) map[string]interface{} {
+	// /api/dcim/devices/ 		Gerät
+	device := map[string]interface{}{
+		"name":        name,
+		"device_type": deviceTypeID,
+		"role":        deviceRoleID,
+		"site":        siteID,
+		"serial":      serial,
+		"description": description,
+		"status":      status,
+	}
+	return device
+}
+
+func createTag() map[string]interface{} {
+	device := map[string]interface{}{
+		"name":        "Guter Tag aus dem richtigen Programm18",
+		"slug":        "guter-tag18",
+		"description": "Das ist ein gutes Gerät, aus dem richtigen Programm",
+	}
+	return device
+}
+func createTagWithParameter(name, slug, description string) map[string]interface{} {
+	device := map[string]interface{}{
+		"name":        name,
+		"slug":        slug,
+		"description": description,
+	}
+	return device
+}
+
+func createModultyp(manufacturerID string) map[string]interface{} {
+	///api/dcim/module-types/		Modultypen
+	device := map[string]interface{}{
+		"model":      "Großes Model18",
+		"partNumber": "Ich bin eine Part Number",
+		//"weight" :      "9",
+		//"weight_unit": "KiloGramm",
+		"description":  "Ich bin eine Beschreibung von einem Großen Model",
+		"comments":     "Und ich bin ein Kommentar",
+		"manufacturer": manufacturerID,
+	}
+	return device
+}
+func createModultypWithParameter(model, partNumber, description, comments, manufacturerID string) map[string]interface{} {
+	///api/dcim/module-types/		Modultypen
+	device := map[string]interface{}{
+		"model":      model,
+		"partNumber": partNumber,
+		//"weight" :      "9",
+		//"weight_unit": "KiloGramm",
+		"description":  description,
+		"comments":     comments,
+		"manufacturer": manufacturerID,
+	}
+	return device
+}
+
+func createdeviceType(manufacturerID string) map[string]interface{} {
+	// /dcim/device-types/ 		Gerätetyp
+	device := map[string]interface{}{
+
+		"manufacturer": manufacturerID,
+		"model":        "Mein-Gerätetyp",
+		"slug":         "mein-geraetetyp",
+		"u_height":     "1",
+	}
+	return device
+}
+func createdeviceTypeWithParameter(manufacturerID, model, slug, uHeight string) map[string]interface{} {
+	// /dcim/device-types/ 		Gerätetyp
+	device := map[string]interface{}{
+		"manufacturer": manufacturerID,
+		"model":        model,
+		"slug":         slug,
+		"u_height":     uHeight,
+	}
+	return device
+}
+
+func createManufacturer() map[string]interface{} {
+	// /dcim/manufacturers/		Hersteller
+	device := map[string]interface{}{
+		"name":        "Großer Hersteller18",
+		"slug":        "grosser-hersteller18",
+		"description": "Hersteller für große Modelle",
+	}
+	return device
+}
+func createManufacturerWithParameter(name, slug, description string) map[string]interface{} {
+	// /dcim/manufacturers/		Hersteller
+	device := map[string]interface{}{
+		"name":        name,
+		"slug":        slug,
+		"description": description,
+	}
+	return device
+}
+
+func createDeviceRole() map[string]interface{} {
+	// /dcim/device-roles/		Geräterolle
+	device := map[string]interface{}{
+		"name":        "Wichtige Rolle18",
+		"slug":        "wichtige-rolle18",
+		"description": "Eine wichtige Rolle für Geräte",
+		"color":       "ff0000", // Rote Farbe als Hex-Code
+	}
+	return device
+}
+func createDeviceRoleWithParameter(name, slug, description, color, active string) map[string]interface{} {
+	// /dcim/device-roles/		Geräterolle
+	device := map[string]interface{}{
+		"name":        name,
+		"slug":        slug,
+		"description": description,
+		"color":       color,
+		"status":      active,
+	}
+	return device
+}
+
+func createSite() map[string]interface{} {
+	// /dcim/sites/		Standorts
+	device := map[string]interface{}{
+		"name":            "GoHauptstandort18",
+		"slug":            "Gohauptstandort18",
+		"description":     "Hauptsitz des Unternehmens",
+		"physicalAddress": "Musterstraße 1, 12345 Musterstadt",
+		"shippingAddress": "Postfach 1001, 12345 Musterstadt",
+		"comments":        "Dies ist der Hauptstandort.",
+		"status":          "active",
+	}
+	return device
+}
+func createSiteWithParameter(name, slug, description, physicalAddress, shippingAddress, comments, status string) map[string]interface{} {
+	// /dcim/sites/		Standorts
+	device := map[string]interface{}{
+		"name":            name,
+		"slug":            slug,
+		"description":     description,
+		"physicalAddress": physicalAddress,
+		"shippingAddress": shippingAddress,
+		"comments":        comments,
+		"status":          status,
+	}
+	return device
+}
diff --git a/applications/inventory-manager-netbox/netboxManager/netboxManager.go b/applications/inventory-manager-netbox/netboxManager/netboxManager.go
new file mode 100644
index 0000000000000000000000000000000000000000..6db84e17211294549ea14e920add6edc591e494e
--- /dev/null
+++ b/applications/inventory-manager-netbox/netboxManager/netboxManager.go
@@ -0,0 +1,320 @@
+package netboxManager
+
+import (
+	"bytes"
+	"encoding/json"
+	"flag"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+
+	"code.fbi.h-da.de/danet/gosdn/api/go/gosdn/networkelement"
+	"code.fbi.h-da.de/danet/gosdn/applications/inventory-manager-netbox/config"
+	"gopkg.in/yaml.v3"
+)
+
+func gehMirNichtAufdenSack() {
+	var device map[string]interface{}
+	device = createDevice()
+	log.Printf("Irgendwas:  %v", device)
+	device = createDeviceWithParameter("name", "deviceTypeID", "deviceRoleID", "siteID", "serial", "description", "active")
+	log.Printf("Irgendwas:  %v", device)
+	device = createTag()
+	log.Printf("Irgendwas:  %v", device)
+	device = createTagWithParameter("name", "slug", "description")
+	log.Printf("Irgendwas:  %v", device)
+	device = createModultyp("10")
+	log.Printf("Irgendwas:  %v", device)
+	device = createModultypWithParameter("model", "partNumber", "description", "comments", "manufacturerID")
+	log.Printf("Irgendwas:  %v", device)
+	device = createdeviceType("10")
+	log.Printf("Irgendwas:  %v", device)
+	device = createdeviceTypeWithParameter("manufacturerID", "model", "slug", "1")
+	log.Printf("Irgendwas:  %v", device)
+	device = createManufacturer()
+	log.Printf("Irgendwas:  %v", device)
+	device = createManufacturerWithParameter("name", "slug", "description")
+	log.Printf("Irgendwas:  %v", device)
+	device = createDeviceRole()
+	log.Printf("Irgendwas:  %v", device)
+	device = createDeviceRoleWithParameter("name", "slug", "description", "ff0000", "offline")
+	log.Printf("Irgendwas:  %v", device)
+	device = createSite()
+	log.Printf("Irgendwas:  %v", device)
+	device = createSiteWithParameter("name", "slug", "description", "physicalAddress", "shippingAddress", "comments", "status")
+	log.Printf("%v", device)
+
+}
+
+// create one Device in Netbox with JSON and HTTP
+func Netboxmanager() error {
+	var device map[string]interface{}
+	//gehMirNichtAufdenSack()
+	// Configpfad aus CLI-Flag holen
+	configFileNetbox := flag.String("configNetbox", "config/configNetbox.yaml", "Pfad zur NetBox-Konfigurationsdatei")
+	flag.Parse()
+	log.Printf("Config-Pfad: %s", *configFileNetbox)
+
+	// Datei lesen
+	data, err := os.ReadFile(*configFileNetbox)
+	if err != nil {
+		log.Printf("Fehler beim Lesen der Konfigurationsdatei: %v", err)
+		return err
+	}
+
+	// YAML in Config-Struct einlesen
+	netboxconfig := &config.NetboxConfig{}
+	if err := yaml.Unmarshal(data, netboxconfig); err != nil {
+		log.Printf("Fehler beim Parsen der YAML-Datei: %v", err)
+		return err
+	}
+	log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress)
+	log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken)
+
+	//Manufacturers Hersteller
+	device = createManufacturerWithParameter("HerstellerName2", "slug2", "description")
+	id, err := Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/manufacturers/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen eines Herstellers: %v", err)
+		return err
+	}
+	manufacturerID := id
+	log.Printf("Hersteller erfolgreich erstellt oder gefunden mit der manufacturerID: %d\n", manufacturerID)
+
+	//Device Types Gerätetyp device_type
+	device = createdeviceTypeWithParameter(strconv.FormatInt(manufacturerID, 10), "model5", "slug5", "1")
+	id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-types/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen des Gerätetyps: %v", err)
+		return err
+	}
+	deviceTypeID := id
+	log.Printf("Gerätetyp erfolgreich erstellt oder gefunden mit der deviceTypeID: %d\n", deviceTypeID)
+
+	deviceTypeID = 16
+	log.Printf("Hacki lösung DeviceRoleID manuell ändern: %d\n", deviceTypeID) //TODO
+
+	//device-roles	Geräterolle
+	device = createDeviceRoleWithParameter("name2", "slug5", "description", "ff0000", "offline")
+	id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-roles/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen der Geräterolle: %v", err)
+		return err
+	}
+	deviceRoleID := id
+	log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der deviceRoleID: %d\n", deviceRoleID)
+
+	device = createSiteWithParameter("Darmstadt", "darmstadt", "description", "physicalAddress", "shippingAddress", "comments", "active")
+	id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/sites/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen der Geräterolle: %v", err)
+		return err
+	}
+	siteID := id
+	log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der siteID: %d\n", siteID)
+
+	device = createDeviceWithParameter("name", strconv.FormatInt(deviceTypeID, 10), strconv.FormatInt(deviceRoleID, 10), strconv.FormatInt(siteID, 10), "serial", "description", "active")
+	id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/devices/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen des Gerätes: %v", err)
+		return err
+	}
+	deviceID := id
+	log.Printf("Gerät erfolgreich erstellt oder gefunden mit der deviceID: %d\n", deviceID)
+
+	return nil
+}
+
+func Netzworhandling(netboxURL, apiToken, api string, device map[string]interface{}) (int64, error) {
+	// Ziel-URL vorbereiten
+	url := "http://" + netboxURL + "/api" + api
+	log.Printf("Die URL lautet: %s", url)
+
+	// JSON kodieren
+	body, err := json.Marshal(device)
+	if err != nil {
+		log.Printf("JSON-Fehler: %v", err)
+		return 0, err
+	}
+
+	// HTTP-Request vorbereiten
+	req, err := http.NewRequest("POST", url, bytes.NewReader(body))
+	if err != nil {
+		log.Printf("Request-Fehler: %v", err)
+		return 0, err
+	}
+
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Authorization", "Token "+apiToken)
+
+	// Request senden
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		log.Printf("Sende-Fehler: %v", err)
+		return 0, err
+	}
+	defer resp.Body.Close()
+
+	// Überprüfe den Statuscode
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		bodyBytes, _ := io.ReadAll(resp.Body)
+		log.Printf("HTTP Fehler: %d - %s", resp.StatusCode, string(bodyBytes))
+		//return 0, err
+	}
+
+	// Antwort dekodieren
+	var result map[string]interface{}
+	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
+		log.Printf("Antwort-Parsing: %v", err)
+		//return 0, err
+	}
+
+	// ID extrahieren
+	if id, ok := result["id"].(float64); ok {
+		return int64(id), nil
+	}
+
+	// Wenn ID fehlt: Fallback → über Gerätename suchen
+	if name, ok := device["name"].(string); ok {
+		log.Println("Keine ID erhalten – versuche bestehendes Gerät mit Namen zu finden:", name)
+
+		queryURL := "http://" + netboxURL + "/api" + api + "?name=" + name
+		log.Println("url zum namen suchen lautet: ", queryURL)
+
+		reqGet, err := http.NewRequest("GET", queryURL, nil)
+		if err != nil {
+			log.Printf("GET-Request-Fehler: %v", err)
+			return 0, err
+		}
+		reqGet.Header.Set("Authorization", "Token "+apiToken)
+
+		respGet, err := http.DefaultClient.Do(reqGet)
+		if err != nil {
+			log.Printf("GET-Fehler: %v", err)
+			return 0, err
+		}
+		defer respGet.Body.Close()
+
+		var getResult map[string]interface{}
+		if err := json.NewDecoder(respGet.Body).Decode(&getResult); err != nil {
+			log.Printf("GET-Antwort-Parsing: %v", err)
+			return 0, err
+		}
+
+		if results, ok := getResult["results"].([]interface{}); ok && len(results) > 0 {
+			if first, ok := results[0].(map[string]interface{}); ok {
+				if id, ok := first["id"].(float64); ok {
+					log.Printf("Bestehendes Gerät gefunden mit ID: %d", int64(id))
+					return int64(id), nil
+				}
+			}
+		}
+
+		log.Printf("Kein existierendes Gerät mit dem Namen gefunden.")
+	}
+
+	log.Printf("keine ID in Antwort gefunden und kein Gerät per Namen auffindbar")
+	return 0, nil
+}
+
+func FeedNetbox(elements *networkelement.GetAllResponse) error {
+	var device map[string]interface{}
+
+	if elements != nil {
+		log.Printf("Es wurden %d Elemente gefunden", len(elements.Mne))
+	}
+	//gehMirNichtAufdenSack()
+	configFileNetboxV2 := flag.String("configNetbox", "config/configNetbox.yaml", "Pfad zur NetBox-Konfigurationsdatei")
+	flag.Parse()
+
+	log.Printf("Config-Pfad: %s", *configFileNetboxV2)
+
+	// Config Datei lesen
+	data, err := os.ReadFile(*configFileNetboxV2)
+	if err != nil {
+		log.Printf("Fehler beim Lesen der Konfigurationsdatei: %v", err)
+		return err
+	}
+
+	// YAML in Config-Struct einlesen
+	netboxconfig := &config.NetboxConfig{}
+	if err := yaml.Unmarshal(data, netboxconfig); err != nil {
+		log.Printf("Fehler beim Parsen der YAML-Datei: %v", err)
+		return err
+	}
+	//log.Printf("Netbox Config Adresse: %v", netboxconfig.NetboxAddress)
+	//log.Printf("Netbox Config Token: %v", netboxconfig.ApiToken)
+
+	//Manufacturers Hersteller
+	device = createManufacturerWithParameter("UniController", "UniController", "Die Wichtige große Box. nicht ausschalten")
+	id, err := Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/manufacturers/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen eines Herstellers: %v", err)
+		return err
+	}
+	manufacturerID := id
+	log.Printf("Hersteller erfolgreich erstellt oder gefunden mit der manufacturerID: %d\n", manufacturerID)
+
+	//Device Types Gerätetyp device_type
+	device = createdeviceTypeWithParameter(strconv.FormatInt(manufacturerID, 10), "MainController", "MainController", "1")
+	id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-types/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen des Gerätetyps: %v", err)
+		return err
+	}
+	deviceTypeID := id
+	log.Printf("Gerätetyp erfolgreich erstellt oder gefunden mit der deviceTypeID: %d\n", deviceTypeID)
+
+	//deviceTypeID = 16
+	//log.Printf("Hacki lösung DeviceRoleID manuell ändern: %d\n", deviceTypeID) //TODO
+
+	//device-roles	Geräterolle
+	device = createDeviceRoleWithParameter("HauptController", "HauptController", "Ganz wichtig Kiste", "ff0000", "offline")
+	id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/device-roles/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen der Geräterolle: %v", err)
+		return err
+	}
+	deviceRoleID := id
+	log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der deviceRoleID: %d\n", deviceRoleID)
+
+	device = createSiteWithParameter("Darmstadt", "darmstadt", "description", "physicalAddress", "shippingAddress", "comments", "active")
+	id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/sites/", device)
+	if err != nil {
+		log.Printf("Fehler beim erstellen der Geräterolle: %v", err)
+		return err
+	}
+	siteID := id
+	log.Printf("Geräterolle erfolgreich erstellt oder gefunden mit der siteID: %d\n", siteID)
+
+	/*
+		for _, element := range elements.Mne {
+			log.Printf("element.Name: %v", element.Name)
+			log.Printf("element.Id: %v", element.Id)
+			log.Printf("element.Plugin: %v", element.Plugin)
+		}
+	*/
+	log.Printf(" ")
+	log.Printf(" ")
+	if elements != nil {
+		for _, element := range elements.Mne {
+
+			deviceTypeID = 3
+			device = createDeviceWithParameter(element.Name, strconv.FormatInt(deviceTypeID, 10), strconv.FormatInt(deviceRoleID, 10), strconv.FormatInt(siteID, 10), element.Id, element.Plugin.String(), "active")
+			id, err = Netzworhandling(netboxconfig.NetboxAddress, netboxconfig.ApiToken, "/dcim/devices/", device)
+			if err != nil {
+				log.Printf("Fehler beim erstellen des Gerätes: %v", err)
+				return err
+			} else {
+
+				log.Printf("Gerät erfolgreich erstellt oder gefunden mit der deviceID: %d\n", id)
+			}
+
+		}
+	} else {
+		log.Fatalf("Der Controller hat keine Daten für mich. Weiter machen Sinnlos^^ elementss ist leer")
+	}
+	return nil
+}