Add examples

examples/Authentication.md

@@ -0,0 +1,60 @@
+### Authentication guide
+
+``` go
+package example
+
+import (
+	"context"
+	"os"
+	"log"
+	"fmt"
+	intersight "github.com/CiscoDevNet/intersight-go"
+)
+
+
+func SetInputs(config *Config) (context.Context, error) {
+	ctx := context.Background()
+	httpSigningInfo := new(intersight.HttpSignatureAuth)
+	httpSigningInfo.KeyId = config.ApiKey
+	httpSigningInfo.PrivateKeyPath = config.SecretKey
+	httpSigningInfo.SigningScheme = intersight.HttpSigningSchemeRsaSha256
+	httpSigningInfo.SigningAlgorithm = intersight.HttpSigningAlgorithmRsaPKCS1v15
+	httpSigningInfo.SignedHeaders = []string{intersight.HttpSignatureParameterRequestTarget,
+		"Host",
+		"Date",
+		"Digest",
+	}
+	if _, err := os.Stat(config.SecretKey); err != nil {
+		err = httpSigningInfo.SetPrivateKey(config.SecretKey)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		httpSigningInfo.PrivateKeyPath = config.SecretKey
+	}
+
+	ctx, err := httpSigningInfo.ContextWithValue(ctx)
+	if err != nil {
+		fmt.Println(err)
+		log.Fatal("Error creating authentication context")
+	}
+
+	return ctx, nil
+}
+
+func getApiClient(config *Config) *Config {
+
+	ctx, err := SetInputs(config)
+	if err != nil {
+		log.Printf("Error: ", err)
+		log.Fatal("Error in authentication context")
+	}
+	config.ctx = ctx
+	cfg := intersight.NewConfiguration()
+	cfg.Host = config.Endpoint
+	cfg.Debug = true
+	apiClient := intersight.NewAPIClient(cfg)
+	config.ApiClient = apiClient
+	return config
+}
+```

examples/BootPolicyCreateUpdate.md

@@ -0,0 +1,152 @@
+### Example to create boot precision policy
+
+``` go
+
+package example
+
+import (
+	"fmt"
+	"os"
+	"log"
+	intersight "github.com/CiscoDevNet/intersight-go"
+)
+
+
+func createBootLocalCdd() *intersight.BootDeviceBase {
+	bootLocalCdd := intersight.NewBootDeviceBase("boot.LocalCdd", "boot.LocalCdd")
+	bootLocalCdd.SetName("local_cdd1")
+	bootLocalCdd.SetEnabled(true)
+	return bootLocalCdd
+}
+
+func createBootLocalDisk() *intersight.BootDeviceBase {
+	bootLocalDisk := intersight.NewBootDeviceBase("boot.LocalDisk", "boot.LocalDisk")
+	bootLocalDisk.SetName("local_disk1")
+	bootLocalDisk.SetEnabled(true)
+	return bootLocalDisk
+}
+
+func createBootSdcard() *intersight.BootDeviceBase {
+	bootSdcard := intersight.NewBootDeviceBase("boot.SdCard", "boot.SdCard")
+	bootSdcard.SetName("boot_sdcard_test")
+	bootSdcard.SetEnabled(true)
+	return bootSdcard
+}
+
+func createBootIscsi() *intersight.BootDeviceBase {
+	bootIscsi := intersight.NewBootDeviceBase("boot.Iscsi", "boot.Iscsi")
+	bootIscsi.SetName("boot_iscsi_test")
+	bootIscsi.SetEnabled(true)
+	return bootIscsi
+}
+
+func createBootVirtualMedia() *intersight.BootDeviceBase {
+	bootVirtualMedia := intersight.NewBootDeviceBase("boot.VirtualMedia", "boot.VirtualMedia")
+	bootVirtualMedia.SetName("boot_virtual_media_test")
+	bootVirtualMedia.SetEnabled(true)
+	return bootVirtualMedia
+}
+
+
+func getOrganizationRelationship(moid string) intersight.OrganizationOrganizationRelationship {
+	organization := new(intersight.OrganizationOrganization)
+	organization.ClassId = "mo.MoRef"
+	organization.ObjectType = "organization.Organization"
+	organization.Moid = &moid
+	organizationRelationship := intersight.OrganizationOrganizationAsOrganizationOrganizationRelationship(organization)
+	return organizationRelationship
+}
+
+func CreateObject(config *Config) {
+	var err error
+	cfg := getApiClient(config)
+	apiClient := cfg.ApiClient
+	ctx := cfg.ctx
+
+	// Get Organization MOID
+	org_resp, r, org_err := apiClient.OrganizationApi.GetOrganizationOrganizationList(ctx).Filter("Name eq 'default'").Execute()
+	if org_err != nil {
+		log.Printf("Error: %v\n", err)
+                log.Printf("HTTP response: %v\n", r)
+                return
+	}
+	org_list := org_resp.OrganizationOrganizationList.GetResults()
+	if len(org_list) == 0 {
+		log.Printf("Couldn't find the organization specified")
+                return
+	}
+	org_moid := org_list[0].MoBaseMo.GetMoid()
+
+	bootLocalCdd := createBootLocalCdd()
+	bootLocalDisk := createBootLocalDisk()
+	organizationRelationship := getOrganizationRelationship(org_moid)
+	bootDevices := []intersight.BootDeviceBase{*bootLocalDisk, *bootLocalCdd}
+	bootPrecisionPolicy := intersight.NewBootPrecisionPolicyWithDefaults()
+	bootPrecisionPolicy.SetName("sample_boot_policy1")
+	bootPrecisionPolicy.SetDescription("sample boot precision policy")
+	bootPrecisionPolicy.SetBootDevices(bootDevices)
+	bootPrecisionPolicy.SetOrganization(organizationRelationship)
+
+	ifMatch := ""
+	ifNoneMatch := ""
+	resp, r, err := apiClient.BootApi.CreateBootPrecisionPolicy(ctx).BootPrecisionPolicy(*bootPrecisionPolicy).IfMatch(ifMatch).IfNoneMatch(ifNoneMatch).Execute()
+	if err != nil {
+		log.Printf("Error: %v\n", err)
+		log.Printf("HTTP response: %v\n", r)
+		return
+	}
+	fmt.Fprintf(os.Stdout, "Response: %v\n", resp)
+
+	//Update
+	id := resp.GetMoid()
+	getapiResponse, r, err := apiClient.BootApi.GetBootPrecisionPolicyByMoid(ctx, id).Execute()
+	if err != nil {
+		log.Printf("Error -> GetBootPrecisionPolicyByMoid: %v\n", err)
+		log.Printf("HTTP response: %v\n", r)
+		return
+	}
+	objMoid := getapiResponse.GetMoid()
+	organizationMoid := getapiResponse.GetOrganization().MoMoRef.GetMoid()
+	bootSdcard := createBootSdcard()
+	bootIscsi := createBootIscsi()
+	organizationRelationship1 := getOrganizationRelationship(organizationMoid)
+	bootDevices1 := []intersight.BootDeviceBase{*bootSdcard, *bootIscsi}
+	updatebootPrecisionPolicy := intersight.NewBootPrecisionPolicyWithDefaults()
+	updatebootPrecisionPolicy.SetName("updated_boot_precision_policy_for_go_test")
+	updatebootPrecisionPolicy.SetDescription("updated description of boot precision policy for testing go example")
+	updatebootPrecisionPolicy.SetBootDevices(bootDevices1)
+	updatebootPrecisionPolicy.SetOrganization(organizationRelationship1)
+	updateResp, r, err := apiClient.BootApi.UpdateBootPrecisionPolicy(ctx, objMoid).BootPrecisionPolicy(*updatebootPrecisionPolicy).IfMatch(ifMatch).Execute()
+	if err != nil {
+		log.Printf("Error -> UpdateBootPrecisionPolicy: %v\n", err)
+		log.Printf("HTTP response: %v\n", r)
+		return
+	}
+	fmt.Fprintf(os.Stdout, "Response : %v\n", updateResp)
+
+	//Patch
+	bootVirtualMedia := createBootVirtualMedia()
+	bootDevices2 := []intersight.BootDeviceBase{*bootVirtualMedia}
+	patchbootPrecisionPolicy := intersight.NewBootPrecisionPolicyWithDefaults()
+	patchbootPrecisionPolicy.SetName("updated_boot_precision_policy_using_patch_go_test")
+	patchbootPrecisionPolicy.SetDescription("update the description of boot precision policy with patch for go test")
+	patchbootPrecisionPolicy.SetBootDevices(bootDevices2)
+	patchbootPrecisionPolicy.SetOrganization(organizationRelationship1)
+	patchResp, r, err := apiClient.BootApi.PatchBootPrecisionPolicy(ctx, objMoid).BootPrecisionPolicy(*patchbootPrecisionPolicy).IfMatch(ifMatch).Execute()
+	if err != nil {
+		log.Printf("Error -> PatchBootPrecisionPolicy: %v\n", err)
+		log.Printf("HTTP response: %v\n", r)
+		return
+	}
+	fmt.Fprintf(os.Stdout, "Response : %v\n", patchResp)
+
+	//Delete
+	fullResp, err := apiClient.BootApi.DeleteBootPrecisionPolicy(ctx, objMoid).Execute()
+	if err != nil {
+		log.Printf("Error -> DeleteBootPrecisionPolicy: %v\n", err)
+		log.Printf("HTTP response: %v\n", fullResp)
+		return
+	}
+
+}
+```

examples/GetApiExample.md

@@ -0,0 +1,25 @@
+### Example to ge the list of SMTP Policies
+
+``` go
+package example
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+func GetObjectList(config *Config) {
+
+	cfg := getApiClient(config)
+	apiClient := cfg.ApiClient
+	ctx := cfg.ctx
+	apiResponse, r, err := apiClient.SmtpApi.GetSmtpPolicyList(ctx).Execute()
+	if err != nil {
+		log.Printf("Error when calling `SmtpApi.GetSmtpPolicyList``: %v\n", err)
+		log.Printf("Full HTTP response: %v\n", r)
+		return
+	}
+	fmt.Fprintf(os.Stdout, "Response from `SmtpApi.GetSmtpPolicyList`: %v\n", apiResponse)
+}
+```

examples/GetApiWithFilter.md

@@ -0,0 +1,33 @@
+### Example for GET API with filter
+
+``` go
+package example
+
+import (
+	"fmt"
+	"log"
+	"os"
+)
+
+func GetObjectListWithFilter(config *Config) {
+	filter := "CreateTime gt 2021-08-29T21:58:33Z"
+	orderby := "CreateTime"
+	top := int32(5)
+	skip := int32(1)
+	select_ := "CreateTime,ModTime"
+	count := false
+	inlinecount := "allpages"
+
+	cfg := getApiClient(config)
+	apiClient := cfg.ApiClient
+	ctx := cfg.ctx
+	apiResponse, r, err := apiClient.ComputeApi.GetComputeRackUnitList(ctx).Filter(filter).Orderby(orderby).Top(top).Skip(skip).Select_(select_).Count(count).Inlinecount(inlinecount).Execute()
+	if err != nil {
+		log.Printf("Error when calling `ComputeApi.GetComputeRckUnitList``: %v\n", err)
+		log.Printf("Full HTTP response: %v\n", r)
+		return
+	}
+
+	fmt.Fprintf(os.Stdout, "Response from `ComputeApi.GetComputeRckUnitList`: %v\n", apiResponse)
+}
+```

examples/policies/adapterConfigPolicy.md

@@ -0,0 +1,65 @@
+#### Example to create policy
+```
+package policy
+
+import (
+	"log"
+
+	intersight "github.com/CiscoDevNet/intersight-go"
+)
+
+func setEth() intersight.AdapterEthSettings {
+	eth := intersight.NewAdapterEthSettings("adapter.EthSettings", "adapter.EthSettings")
+	eth.SetLldpEnabled(true)
+	return *eth
+}
+
+func setFc() intersight.AdapterFcSettings {
+	fc := intersight.NewAdapterFcSettings("adapter.FcSettings", "adapter.FcSettings")
+	fc.SetFipEnabled(true)
+	return *fc
+}
+
+func setSettings() *intersight.AdapterAdapterConfig {
+	adapterConfig := intersight.NewAdapterAdapterConfigWithDefaults()
+	ethSettings := setEth()
+	fcSettings := setFc()
+	adapterConfig.SetSlotId("1")
+	adapterConfig.SetEthSettings(ethSettings)
+	adapterConfig.SetFcSettings(fcSettings)
+	return adapterConfig
+}
+
+func setSettingsMlom() *intersight.AdapterAdapterConfig {
+	adapterConfig := intersight.NewAdapterAdapterConfigWithDefaults()
+	ethSettings := setEth()
+	fcSettings := setFc()
+	adapterConfig.SetSlotId("MLOM")
+	adapterConfig.SetEthSettings(ethSettings)
+	adapterConfig.SetFcSettings(fcSettings)
+	return adapterConfig
+}
+
+
+func CreateAdapterPolicy(config *Config) string {
+	var err error
+	cfg := getApiClient(config)
+	apiClient := cfg.ApiClient
+	ctx := cfg.ctx
+	settings := setSettings()
+	settingsMlom := setSettingsMlom()
+	settingsArr := []intersight.AdapterAdapterConfig{*settings, *settingsMlom}
+	org_moid := getDefaultOrgMoid(config)
+	organizationRelationship := getOrganizationRelationship(org_moid)
+	adapterConfigPolicy := intersight.NewAdapterConfigPolicyWithDefaults()
+	adapterConfigPolicy.SetSettings(settingsArr)
+	adapterConfigPolicy.SetName("tf_adapter_config_sdk")
+	adapterConfigPolicy.SetDescription("test policy")
+	adapterConfigPolicy.SetOrganization(organizationRelationship)
+	resp, _, err := apiClient.AdapterApi.CreateAdapterConfigPolicy(ctx).AdapterConfigPolicy(*adapterConfigPolicy).Execute()
+	if err != nil {
+		log.Fatalf("Error: %v\n", err)
+	}
+	return resp.GetMoid()
+}
+```