icinga

crud.go (7355B)

---

 // Code generated by ./crud.sh -o crud.go; DO NOT EDIT.
 
 package icinga
 
 import (
 	"fmt"
 	"net/url"
 )
 
 // Hosts returns a slice of Host matching the filter expression filter.
 // If no hosts match, error wraps ErrNoMatch.
 // To fetch all host, set filter to the empty string ("").
 func (c *Client) Hosts(filter string) ([]Host, error) {
 	objects, err := c.filterObjects("/objects/hosts", filter)
 	if err != nil {
 		return nil, fmt.Errorf("get hosts filter %s: %w", filter, err)
 	}
 	var hosts []Host
 	for _, o := range objects {
 		v, ok := o.(Host)
 		if !ok {
 			return nil, fmt.Errorf("get hosts filter %s: %T in response", filter, v)
 		}
 		hosts = append(hosts, v)
 	}
 	return hosts, nil
 }
 
 // LookupHost returns the Host identified by name. If no Host is found, error
 // wraps ErrNotExist.
 func (c *Client) LookupHost(name string) (Host, error) {
 	obj, err := c.lookupObject("/objects/hosts/" + url.PathEscape(name))
 	if err != nil {
 		return Host{}, fmt.Errorf("lookup host %s: %w", name, err)
 	}
 	v, ok := obj.(Host)
 	if !ok {
 		return Host{}, fmt.Errorf("lookup host %s: result type %T is not Host", name, v)
 	}
 	return v, nil
 }
 
 // CreateHost creates host. Some fields of host must be set for successful
 // creation; see the type definition of Host for details.
 func (c *Client) CreateHost(host Host) error {
 	if err := c.createObject(host); err != nil {
 		return fmt.Errorf("create host %s: %w", host.Name, err)
 	}
 	return nil
 }
 
 // DeleteHost deletes the Host identified by name. If cascade is true, objects
 // depending on the Host are also deleted. If no Host is found, error wraps
 // ErrNotExist.
 func (c *Client) DeleteHost(name string, cascade bool) error {
 	if err := c.deleteObject("/objects/hosts/"+url.PathEscape(name), cascade); err != nil {
 		return fmt.Errorf("delete host %s: %w", name, err)
 	}
 	return nil
 }
 // Services returns a slice of Service matching the filter expression filter.
 // If no services match, error wraps ErrNoMatch.
 // To fetch all service, set filter to the empty string ("").
 func (c *Client) Services(filter string) ([]Service, error) {
 	objects, err := c.filterObjects("/objects/services", filter)
 	if err != nil {
 		return nil, fmt.Errorf("get services filter %s: %w", filter, err)
 	}
 	var services []Service
 	for _, o := range objects {
 		v, ok := o.(Service)
 		if !ok {
 			return nil, fmt.Errorf("get services filter %s: %T in response", filter, v)
 		}
 		services = append(services, v)
 	}
 	return services, nil
 }
 
 // LookupService returns the Service identified by name. If no Service is found, error
 // wraps ErrNotExist.
 func (c *Client) LookupService(name string) (Service, error) {
 	obj, err := c.lookupObject("/objects/services/" + url.PathEscape(name))
 	if err != nil {
 		return Service{}, fmt.Errorf("lookup service %s: %w", name, err)
 	}
 	v, ok := obj.(Service)
 	if !ok {
 		return Service{}, fmt.Errorf("lookup service %s: result type %T is not Service", name, v)
 	}
 	return v, nil
 }
 
 // CreateService creates service. Some fields of service must be set for successful
 // creation; see the type definition of Service for details.
 func (c *Client) CreateService(service Service) error {
 	if err := c.createObject(service); err != nil {
 		return fmt.Errorf("create service %s: %w", service.Name, err)
 	}
 	return nil
 }
 
 // DeleteService deletes the Service identified by name. If cascade is true, objects
 // depending on the Service are also deleted. If no Service is found, error wraps
 // ErrNotExist.
 func (c *Client) DeleteService(name string, cascade bool) error {
 	if err := c.deleteObject("/objects/services/"+url.PathEscape(name), cascade); err != nil {
 		return fmt.Errorf("delete service %s: %w", name, err)
 	}
 	return nil
 }
 // Users returns a slice of User matching the filter expression filter.
 // If no users match, error wraps ErrNoMatch.
 // To fetch all user, set filter to the empty string ("").
 func (c *Client) Users(filter string) ([]User, error) {
 	objects, err := c.filterObjects("/objects/users", filter)
 	if err != nil {
 		return nil, fmt.Errorf("get users filter %s: %w", filter, err)
 	}
 	var users []User
 	for _, o := range objects {
 		v, ok := o.(User)
 		if !ok {
 			return nil, fmt.Errorf("get users filter %s: %T in response", filter, v)
 		}
 		users = append(users, v)
 	}
 	return users, nil
 }
 
 // LookupUser returns the User identified by name. If no User is found, error
 // wraps ErrNotExist.
 func (c *Client) LookupUser(name string) (User, error) {
 	obj, err := c.lookupObject("/objects/users/" + url.PathEscape(name))
 	if err != nil {
 		return User{}, fmt.Errorf("lookup user %s: %w", name, err)
 	}
 	v, ok := obj.(User)
 	if !ok {
 		return User{}, fmt.Errorf("lookup user %s: result type %T is not User", name, v)
 	}
 	return v, nil
 }
 
 // CreateUser creates user. Some fields of user must be set for successful
 // creation; see the type definition of User for details.
 func (c *Client) CreateUser(user User) error {
 	if err := c.createObject(user); err != nil {
 		return fmt.Errorf("create user %s: %w", user.Name, err)
 	}
 	return nil
 }
 
 // DeleteUser deletes the User identified by name. If cascade is true, objects
 // depending on the User are also deleted. If no User is found, error wraps
 // ErrNotExist.
 func (c *Client) DeleteUser(name string, cascade bool) error {
 	if err := c.deleteObject("/objects/users/"+url.PathEscape(name), cascade); err != nil {
 		return fmt.Errorf("delete user %s: %w", name, err)
 	}
 	return nil
 }
 // HostGroups returns a slice of HostGroup matching the filter expression filter.
 // If no hostgroups match, error wraps ErrNoMatch.
 // To fetch all hostgroup, set filter to the empty string ("").
 func (c *Client) HostGroups(filter string) ([]HostGroup, error) {
 	objects, err := c.filterObjects("/objects/hostgroups", filter)
 	if err != nil {
 		return nil, fmt.Errorf("get hostgroups filter %s: %w", filter, err)
 	}
 	var hostgroups []HostGroup
 	for _, o := range objects {
 		v, ok := o.(HostGroup)
 		if !ok {
 			return nil, fmt.Errorf("get hostgroups filter %s: %T in response", filter, v)
 		}
 		hostgroups = append(hostgroups, v)
 	}
 	return hostgroups, nil
 }
 
 // LookupHostGroup returns the HostGroup identified by name. If no HostGroup is found, error
 // wraps ErrNotExist.
 func (c *Client) LookupHostGroup(name string) (HostGroup, error) {
 	obj, err := c.lookupObject("/objects/hostgroups/" + url.PathEscape(name))
 	if err != nil {
 		return HostGroup{}, fmt.Errorf("lookup hostgroup %s: %w", name, err)
 	}
 	v, ok := obj.(HostGroup)
 	if !ok {
 		return HostGroup{}, fmt.Errorf("lookup hostgroup %s: result type %T is not HostGroup", name, v)
 	}
 	return v, nil
 }
 
 // CreateHostGroup creates hostgroup. Some fields of hostgroup must be set for successful
 // creation; see the type definition of HostGroup for details.
 func (c *Client) CreateHostGroup(hostgroup HostGroup) error {
 	if err := c.createObject(hostgroup); err != nil {
 		return fmt.Errorf("create hostgroup %s: %w", hostgroup.Name, err)
 	}
 	return nil
 }
 
 // DeleteHostGroup deletes the HostGroup identified by name. If cascade is true, objects
 // depending on the HostGroup are also deleted. If no HostGroup is found, error wraps
 // ErrNotExist.
 func (c *Client) DeleteHostGroup(name string, cascade bool) error {
 	if err := c.deleteObject("/objects/hostgroups/"+url.PathEscape(name), cascade); err != nil {
 		return fmt.Errorf("delete hostgroup %s: %w", name, err)
 	}
 	return nil
 }