add missing methods for location service

Author: olegy89

pkg/fixtures/locations/bandwidth_option_get_response.json

@@ -0,0 +1,6 @@
+{
+    "id": 348,
+    "name": "20002 GB",
+    "type": "bytes",
+    "commit": 20002000000
+}

pkg/fixtures/locations/drive_model_get_response.json

@@ -0,0 +1,8 @@
+{
+    "id": 369,
+    "name": "ssd-model-504",
+    "capacity": 100,
+    "interface": "SATA3",
+    "form_factor": "2.5",
+    "media_type": "SSD"
+}

pkg/fixtures/locations/get_response.json

@@ -0,0 +1,18 @@
+{
+    "id": 1108,
+    "name": "location2251",
+    "status": "active",
+    "code": "location2251",
+    "supported_features": [
+        "disaggregated_public_ports",
+        "disaggregated_private_ports",
+        "no_public_network",
+        "no_private_ip",
+        "no_public_ip_address",
+        "host_rescue_mode",
+        "oob_public_access"
+    ],
+    "l2_segments_enabled": false,
+    "private_racks_enabled": false,
+    "load_balancers_enabled": false
+}

pkg/fixtures/locations/operating_system_option_get_response.json

@@ -0,0 +1,14 @@
+{
+    "id": 50,
+    "full_name": "Ubuntu 18.04-server x86_64",
+    "name": "Ubuntu",
+    "version": "18.04-server",
+    "arch": "x86_64",
+    "filesystems": [
+        "ext2",
+        "ext4",
+        "swap",
+        "xfs",
+        "reiser"
+    ]
+}

pkg/fixtures/locations/sbm_flavor_get_response.json

@@ -0,0 +1,16 @@
+{
+    "id": 119,
+    "name": "P-101",
+    "cpu_name": "cpu_name",
+    "cpu_count": 1,
+    "cpu_cores_count": 2,
+    "cpu_frequency": "3.8",
+    "ram_size": 4096,
+    "drives_configuration": "",
+    "public_uplink_model_id": 117,
+    "public_uplink_model_name": "uplink-model-name-36",
+    "private_uplink_model_id": 116,
+    "private_uplink_model_name": "uplink-model-name-35",
+    "bandwidth_id": 118,
+    "bandwidth_name": "public-bandwidth-model-21"
+}

pkg/fixtures/locations/server_model_option_get_response.json

@@ -0,0 +1,30 @@
+{
+    "id": 231,
+    "name": "server-model-469",
+    "cpu_name": "cpu-model-model-468",
+    "cpu_count": 2,
+    "cpu_cores_count": 16,
+    "cpu_frequency": 1970,
+    "ram": 32,
+    "ram_type": "DDR3",
+    "max_ram": 384,
+    "has_raid_controller": true,
+    "raid_controller_name": "AHCI controller",
+    "drive_slots_count": 8,
+    "drive_slots": [
+        {
+            "position": 0,
+            "interface": "SAS",
+            "form_factor": "2_5",
+            "drive_model_id": 234,
+            "hot_swappable": false
+        },
+        {
+            "position": 1,
+            "interface": "SAS",
+            "form_factor": "2_5",
+            "drive_model_id": 235,
+            "hot_swappable": false
+        }
+    ]
+}

pkg/fixtures/locations/uplink_option_get_response.json

@@ -0,0 +1,7 @@
+{
+    "id": 294,
+    "name": "Private 1 Gbps without redundancy",
+    "type": "private",
+    "speed": 1000,
+    "redundancy": false
+}

pkg/locations.go

@@ -1,29 +1,42 @@
 package serverscom
 
+import (
+	"context"
+	"encoding/json"
+)
+
 const (
 	locationListPath = "/locations"
+	locationPath     = "/locations/%d"
 
 	serverModelOptionListPath = "/locations/%d/order_options/server_models"
+	serverModelOptionPath     = "/locations/%d/order_options/server_models/%d"
 
 	ramOptionListPath = "/locations/%d/order_options/server_models/%d/ram"
 
 	operatingSystemOptionListPath = "/locations/%d/order_options/server_models/%d/operating_systems"
+	operatingSystemOptionPath     = "/locations/%d/order_options/server_models/%d/operating_systems/%d"
 
 	driveModelListPath = "/locations/%d/order_options/server_models/%d/drive_models"
+	driveModelPath     = "/locations/%d/order_options/server_models/%d/drive_models/%d"
 
 	uplinkOptionListPath = "/locations/%d/order_options/server_models/%d/uplink_models"
+	uplinkOptionPath     = "/locations/%d/order_options/server_models/%d/uplink_models/%d"
 
 	bandwidthOptionListPath = "/locations/%d/order_options/server_models/%d/uplink_models/%d/bandwidth"
+	bandwidthOptionPath     = "/locations/%d/order_options/server_models/%d/uplink_models/%d/bandwidth/%d"
 
-	sbmFlavorOptionListPath = "/locations/%d/order_options/sbm_flavor_models"
-
+	sbmFlavorOptionListPath          = "/locations/%d/order_options/sbm_flavor_models"
+	sbmFlavorOptionPath              = "/locations/%d/order_options/sbm_flavor_models/%d"
 	sbmOperatingSystemOptionListPath = "/locations/%d/order_options/sbm_flavor_models/%d/operating_systems"
+	sbmOperatingSystemOptionPath     = "/locations/%d/order_options/sbm_flavor_models/%d/operating_systems/%d"
 )
 
 // LocationsService is an interface to interfacing with the Location and Order options endpoints
 // API documentation:
 // https://developers.servers.com/api-documentation/v1/#tag/Location
 // https://developers.servers.com/api-documentation/v1/#tag/Server-Model-Option
+// https://developers.servers.com/api-documentation/v1/#tag/SBM-Flavor-Model-Option
 // https://developers.servers.com/api-documentation/v1/#tag/Drive-Model-Option
 // https://developers.servers.com/api-documentation/v1/#tag/Ram-Option
 // https://developers.servers.com/api-documentation/v1/#tag/Operating-System-Option
@@ -34,14 +47,22 @@ type LocationsService interface {
 	Collection() Collection[Location]
 
 	// Generic operations
-	ServerModelOptions(LocationID int64) Collection[ServerModelOption]
-	RAMOptions(LocationID, ServerModelID int64) Collection[RAMOption]
-	OperatingSystemOptions(LocationID, ServerModelID int64) Collection[OperatingSystemOption]
-	DriveModelOptions(LocationID, ServerModelID int64) Collection[DriveModel]
-	UplinkOptions(LocationID, ServerModelID int64) Collection[UplinkOption]
-	BandwidthOptions(LocationID, ServerModelID, uplinkID int64) Collection[BandwidthOption]
-	SBMFlavorOptions(LocationID int64) Collection[SBMFlavor]
-	SBMOperatingSystemOptions(LocationID, sbmFlavorModelID int64) Collection[OperatingSystemOption]
+	GetLocation(ctx context.Context, locationID int64) (*Location, error)
+	ServerModelOptions(locationID int64) Collection[ServerModelOption]
+	GetServerModelOption(ctx context.Context, locationID, serverModelID int64) (*ServerModelOptionDetail, error)
+	RAMOptions(locationID, serverModelID int64) Collection[RAMOption]
+	OperatingSystemOptions(locationID, serverModelID int64) Collection[OperatingSystemOption]
+	GetOperatingSystemOption(ctx context.Context, locationID, serverModelID, operatingSystemID int64) (*OperatingSystemOption, error)
+	DriveModelOptions(locationID, serverModelID int64) Collection[DriveModel]
+	GetDriveModelOption(ctx context.Context, locationID, serverModelID, driveModelID int64) (*DriveModel, error)
+	UplinkOptions(locationID, serverModelID int64) Collection[UplinkOption]
+	GetUplinkOption(ctx context.Context, locationID, serverModelID, uplinkModelID int64) (*UplinkOption, error)
+	BandwidthOptions(locationID, serverModelID, uplinkID int64) Collection[BandwidthOption]
+	GetBandwidthOption(ctx context.Context, locationID, serverModelID, uplinkModelID, bandwidthID int64) (*BandwidthOption, error)
+	SBMFlavorOptions(locationID int64) Collection[SBMFlavor]
+	GetSBMFlavorOption(ctx context.Context, locationID, sbmFlavorModelID int64) (*SBMFlavor, error)
+	SBMOperatingSystemOptions(locationID, sbmFlavorModelID int64) Collection[OperatingSystemOption]
+	GetSBMOperatingSystemOption(ctx context.Context, locationID, sbmFlavorModelID, operatingSystemID int64) (*OperatingSystemOption, error)
 }
 
 // LocationsHandler handles operations around cloud instances
@@ -54,13 +75,47 @@ func (h *LocationsHandler) Collection() Collection[Location] {
 	return NewCollection[Location](h.client, locationListPath)
 }
 
+// GetLocation returns a location
+func (h *LocationsHandler) GetLocation(ctx context.Context, id int64) (*Location, error) {
+	url := h.client.buildURL(locationPath, id)
+
+	body, err := h.client.buildAndExecRequest(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	location := new(Location)
+	if err := json.Unmarshal(body, location); err != nil {
+		return nil, err
+	}
+
+	return location, nil
+}
+
 // ServerModelOptions builds a new Collection[ServerModelOption interface
 func (h *LocationsHandler) ServerModelOptions(LocationID int64) Collection[ServerModelOption] {
 	path := h.client.buildPath(serverModelOptionListPath, []interface{}{LocationID}...)
 
 	return NewCollection[ServerModelOption](h.client, path)
 }
 
+// GetServerModelOption returns a server model option
+func (h *LocationsHandler) GetServerModelOption(ctx context.Context, locationID, serverModelID int64) (*ServerModelOptionDetail, error) {
+	url := h.client.buildURL(serverModelOptionPath, locationID, serverModelID)
+
+	body, err := h.client.buildAndExecRequest(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	serverModelOption := new(ServerModelOptionDetail)
+	if err := json.Unmarshal(body, serverModelOption); err != nil {
+		return nil, err
+	}
+
+	return serverModelOption, nil
+}
+
 // RAMOptions builds a new Collection[RAMOption] interface
 func (h *LocationsHandler) RAMOptions(LocationID, ServerModelID int64) Collection[RAMOption] {
 	path := h.client.buildPath(ramOptionListPath, []interface{}{LocationID, ServerModelID}...)
@@ -75,37 +130,139 @@ func (h *LocationsHandler) OperatingSystemOptions(LocationID, ServerModelID int6
 	return NewCollection[OperatingSystemOption](h.client, path)
 }
 
+// GetOperatingSystemOption returns an operating system option
+func (h *LocationsHandler) GetOperatingSystemOption(ctx context.Context, locationID, serverModelID, operatingSystemID int64) (*OperatingSystemOption, error) {
+	url := h.client.buildURL(operatingSystemOptionPath, locationID, serverModelID, operatingSystemID)
+
+	body, err := h.client.buildAndExecRequest(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	operatingSystemOption := new(OperatingSystemOption)
+	if err := json.Unmarshal(body, operatingSystemOption); err != nil {
+		return nil, err
+	}
+
+	return operatingSystemOption, nil
+}
+
 // DriveModelOptions builds a new Collection[DriveModel]  interface
 func (h *LocationsHandler) DriveModelOptions(LocationID, ServerModelID int64) Collection[DriveModel] {
 	path := h.client.buildPath(driveModelListPath, []interface{}{LocationID, ServerModelID}...)
 
 	return NewCollection[DriveModel](h.client, path)
 }
 
+// GetDriveModelOption returns a drive model
+func (h *LocationsHandler) GetDriveModelOption(ctx context.Context, locationID, serverModelID, driveModelID int64) (*DriveModel, error) {
+	url := h.client.buildURL(driveModelPath, locationID, serverModelID, driveModelID)
+
+	body, err := h.client.buildAndExecRequest(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	driveModel := new(DriveModel)
+	if err := json.Unmarshal(body, driveModel); err != nil {
+		return nil, err
+	}
+
+	return driveModel, nil
+}
+
 // UplinkOptions builds a new Collection[UplinkOption] interface
 func (h *LocationsHandler) UplinkOptions(LocationID, ServerModelID int64) Collection[UplinkOption] {
 	path := h.client.buildPath(uplinkOptionListPath, []interface{}{LocationID, ServerModelID}...)
 
 	return NewCollection[UplinkOption](h.client, path)
 }
 
+// GetUplinkOption returns an uplink model
+func (h *LocationsHandler) GetUplinkOption(ctx context.Context, locationID, serverModelID, uplinkModelID int64) (*UplinkOption, error) {
+	url := h.client.buildURL(uplinkOptionPath, locationID, serverModelID, uplinkModelID)
+
+	body, err := h.client.buildAndExecRequest(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	uplinkOption := new(UplinkOption)
+	if err := json.Unmarshal(body, uplinkOption); err != nil {
+		return nil, err
+	}
+
+	return uplinkOption, nil
+}
+
 // BandwidthOptions builds a new Collection[BandwidthOption] interface
 func (h *LocationsHandler) BandwidthOptions(LocationID, ServerModelID, uplinkID int64) Collection[BandwidthOption] {
 	path := h.client.buildPath(bandwidthOptionListPath, []interface{}{LocationID, ServerModelID, uplinkID}...)
 
 	return NewCollection[BandwidthOption](h.client, path)
 }
 
+// GetBandwidthOption returns a bandwidth option
+func (h *LocationsHandler) GetBandwidthOption(ctx context.Context, locationID, serverModelID, uplinkModelID, bandwidthID int64) (*BandwidthOption, error) {
+	url := h.client.buildURL(bandwidthOptionPath, locationID, serverModelID, uplinkModelID, bandwidthID)
+
+	body, err := h.client.buildAndExecRequest(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	bandwidthOption := new(BandwidthOption)
+	if err := json.Unmarshal(body, bandwidthOption); err != nil {
+		return nil, err
+	}
+
+	return bandwidthOption, nil
+}
+
 // SBMFlavorOptions builds a new Collection[SBMFlavor] interface
 func (h *LocationsHandler) SBMFlavorOptions(LocationID int64) Collection[SBMFlavor] {
 	path := h.client.buildPath(sbmFlavorOptionListPath, []interface{}{LocationID}...)
 
 	return NewCollection[SBMFlavor](h.client, path)
 }
 
+// GetSBMFlavorOption returns an SBM flavor model
+func (h *LocationsHandler) GetSBMFlavorOption(ctx context.Context, locationID, sbmFlavorModelID int64) (*SBMFlavor, error) {
+	url := h.client.buildURL(sbmFlavorOptionPath, locationID, sbmFlavorModelID)
+
+	body, err := h.client.buildAndExecRequest(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	sbmFlavor := new(SBMFlavor)
+	if err := json.Unmarshal(body, sbmFlavor); err != nil {
+		return nil, err
+	}
+
+	return sbmFlavor, nil
+}
+
 // SBMOperatingSystemOptions builds a new Collection[OperatingSystemOption] interface
 func (h *LocationsHandler) SBMOperatingSystemOptions(LocationID, SBMFlavorModelID int64) Collection[OperatingSystemOption] {
 	path := h.client.buildPath(sbmOperatingSystemOptionListPath, []interface{}{LocationID, SBMFlavorModelID}...)
 
 	return NewCollection[OperatingSystemOption](h.client, path)
 }
+
+// GetSBMOperatingSystemOption returns an SBM operating system option
+func (h *LocationsHandler) GetSBMOperatingSystemOption(ctx context.Context, locationID, sbmFlavorModelID, operatingSystemID int64) (*OperatingSystemOption, error) {
+	url := h.client.buildURL(sbmOperatingSystemOptionPath, locationID, sbmFlavorModelID, operatingSystemID)
+
+	body, err := h.client.buildAndExecRequest(ctx, "GET", url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	operatingSystemOption := new(OperatingSystemOption)
+	if err := json.Unmarshal(body, operatingSystemOption); err != nil {
+		return nil, err
+	}
+
+	return operatingSystemOption, nil
+}