github.com/gophercloud/gophercloud@v1.11.0/openstack/clustering/v1/receivers/requests.go (about)

     1  package receivers
     2  
     3  import (
     4  	"github.com/gophercloud/gophercloud"
     5  	"github.com/gophercloud/gophercloud/pagination"
     6  )
     7  
     8  // ReceiverType represents a valid type of receiver
     9  type ReceiverType string
    10  
    11  const (
    12  	WebhookReceiver ReceiverType = "webhook"
    13  	MessageReceiver ReceiverType = "message"
    14  )
    15  
    16  // CreateOptsBuilder allows extensions to add additional parameters to the
    17  // Create request.
    18  type CreateOptsBuilder interface {
    19  	ToReceiverCreateMap() (map[string]interface{}, error)
    20  }
    21  
    22  // CreatOpts represents options used to create a receiver.
    23  type CreateOpts struct {
    24  	Name      string                 `json:"name" required:"true"`
    25  	ClusterID string                 `json:"cluster_id,omitempty"`
    26  	Type      ReceiverType           `json:"type" required:"true"`
    27  	Action    string                 `json:"action,omitempty"`
    28  	Actor     map[string]interface{} `json:"actor,omitempty"`
    29  	Params    map[string]interface{} `json:"params,omitempty"`
    30  }
    31  
    32  // ToReceiverCreateMap constructs a request body from CreateOpts.
    33  func (opts CreateOpts) ToReceiverCreateMap() (map[string]interface{}, error) {
    34  	return gophercloud.BuildRequestBody(opts, "receiver")
    35  }
    36  
    37  // Create requests the creation of a new receiver.
    38  func Create(client *gophercloud.ServiceClient, opts CreateOptsBuilder) (r CreateResult) {
    39  	b, err := opts.ToReceiverCreateMap()
    40  	if err != nil {
    41  		r.Err = err
    42  		return
    43  	}
    44  	resp, err := client.Post(createURL(client), b, &r.Body, &gophercloud.RequestOpts{
    45  		OkCodes: []int{200, 201, 202},
    46  	})
    47  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
    48  	return
    49  }
    50  
    51  // UpdateOptsBuilder allows extensions to add additional parameters to the
    52  // Update request.
    53  type UpdateOptsBuilder interface {
    54  	ToReceiverUpdateMap() (map[string]interface{}, error)
    55  }
    56  
    57  // UpdateOpts represents options used to update a receiver.
    58  type UpdateOpts struct {
    59  	Name   string                 `json:"name,omitempty"`
    60  	Action string                 `json:"action,omitempty"`
    61  	Params map[string]interface{} `json:"params,omitempty"`
    62  }
    63  
    64  // ToReceiverUpdateMap constructs a request body from UpdateOpts.
    65  func (opts UpdateOpts) ToReceiverUpdateMap() (map[string]interface{}, error) {
    66  	return gophercloud.BuildRequestBody(opts, "receiver")
    67  }
    68  
    69  // Update requests the update of a receiver.
    70  func Update(client *gophercloud.ServiceClient, id string, opts UpdateOptsBuilder) (r UpdateResult) {
    71  	b, err := opts.ToReceiverUpdateMap()
    72  	if err != nil {
    73  		r.Err = err
    74  		return
    75  	}
    76  	resp, err := client.Patch(updateURL(client, id), b, &r.Body, &gophercloud.RequestOpts{
    77  		OkCodes: []int{200, 201},
    78  	})
    79  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
    80  	return
    81  }
    82  
    83  // Get retrieves details of a single receiver. Use Extract to convert its result into a Receiver.
    84  func Get(client *gophercloud.ServiceClient, id string) (r GetResult) {
    85  	resp, err := client.Get(getURL(client, id), &r.Body, &gophercloud.RequestOpts{OkCodes: []int{200}})
    86  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
    87  	return
    88  }
    89  
    90  // ListOptsBuilder allows extensions to add additional parameters to the
    91  // List request.
    92  type ListOptsBuilder interface {
    93  	ToReceiverListQuery() (string, error)
    94  }
    95  
    96  // ListOpts represents options used to list recievers.
    97  type ListOpts struct {
    98  	Limit         int    `q:"limit"`
    99  	Marker        string `q:"marker"`
   100  	Sort          string `q:"sort"`
   101  	GlobalProject *bool  `q:"global_project"`
   102  	Name          string `q:"name"`
   103  	Type          string `q:"type"`
   104  	ClusterID     string `q:"cluster_id"`
   105  	Action        string `q:"action"`
   106  	User          string `q:"user"`
   107  }
   108  
   109  // ToReceiverListQuery formats a ListOpts into a query string.
   110  func (opts ListOpts) ToReceiverListQuery() (string, error) {
   111  	q, err := gophercloud.BuildQueryString(opts)
   112  	return q.String(), err
   113  }
   114  
   115  // List instructs OpenStack to provide a list of cluster.
   116  func List(client *gophercloud.ServiceClient, opts ListOptsBuilder) pagination.Pager {
   117  	url := listURL(client)
   118  	if opts != nil {
   119  		query, err := opts.ToReceiverListQuery()
   120  		if err != nil {
   121  			return pagination.Pager{Err: err}
   122  		}
   123  		url += query
   124  	}
   125  
   126  	return pagination.NewPager(client, url, func(r pagination.PageResult) pagination.Page {
   127  		return ReceiverPage{pagination.LinkedPageBase{PageResult: r}}
   128  	})
   129  }
   130  
   131  // Delete deletes the specified receiver ID.
   132  func Delete(client *gophercloud.ServiceClient, id string) (r DeleteResult) {
   133  	resp, err := client.Delete(deleteURL(client, id), nil)
   134  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   135  	return
   136  }
   137  
   138  // Notify Notifies message type receiver
   139  func Notify(client *gophercloud.ServiceClient, id string) (r NotifyResult) {
   140  	resp, err := client.Post(notifyURL(client, id), nil, nil, &gophercloud.RequestOpts{
   141  		OkCodes: []int{204},
   142  	})
   143  	_, r.Header, r.Err = gophercloud.ParseResponse(resp, err)
   144  	return
   145  }