Go License Client

29min
Note: Read Common﻿ before this.
Importing the License Client
Go

import (
	"gitlab.com/l3178/sdk-go/license_client"
	"gitlab.com/l3178/sdk-go/core/auth"
	core_request "gitlab.com/l3178/sdk-go/core/models/request"
)

import (
	"gitlab.com/l3178/sdk-go/license_client"
	"gitlab.com/l3178/sdk-go/core/auth"
	core_request "gitlab.com/l3178/sdk-go/core/models/request"
)
﻿
Create LicenseClient
The following function uses the default CryptoProvider and DataLocation to encrypt, store, and decrypt the license file. You can implement your custom CryptoProvider and DataLocation the interface structure.
Go
config := license_client.NewLicenseClientConfiguration("apiKey", "sharedKey", "productCode")
client := license_client.NewLicenseClient(config)
config := license_client.NewLicenseClientConfiguration("apiKey", "sharedKey", "productCode")
client := license_client.NewLicenseClient(config)
﻿
Create Custom LicenseClient
Implement the CryptoProvider and DataLocation interfaces to create custom implementations for these components, and use them to configure the license client.
Go
// implement the interface:
//type CryptoProvider interface {
//	Encrypt(core_models.LicenseFile, string) (interface{}, error)
//	Decrypt(interface{}, string) (interface{}, error)
//}
type CustomCryptoProvider struct{}
func (d CustomCryptoProvider) Encrypt(license_file core_models.LicenseFile, password string) (interface{}, error) {
// your custom implementation
}
func (d CustomCryptoProvider) Decrypt(data interface{}, password string) (interface{}, error) {
// your custom implementation
}

// implement the interface:
//type DataLocation interface {
//	DataDirectory() (string, error)
//	LicenseFileName(string) string
//}
type CustomDataLocation struct{}
func (d CustomDataLocation) DataDirectory() (string, error) {
// your custom implementation
}
func (d CustomDataLocation) LicenseFileName(productCode string) string {
// your custom implementation
}

config := license_client.NewLicenseClientConfigurationCustom(CustomCryptoProvider, CustomDataLocation, "apiKey", "sharedKey", "productCode")
client := license_client.NewLicenseClient(config)

// implement the interface:
//type CryptoProvider interface {
//	Encrypt(core_models.LicenseFile, string) (interface{}, error)
//	Decrypt(interface{}, string) (interface{}, error)
//}
type CustomCryptoProvider struct{}
func (d CustomCryptoProvider) Encrypt(license_file core_models.LicenseFile, password string) (interface{}, error) {
// your custom implementation
}
func (d CustomCryptoProvider) Decrypt(data interface{}, password string) (interface{}, error) {
// your custom implementation
}

// implement the interface:
//type DataLocation interface {
//	DataDirectory() (string, error)
//	LicenseFileName(string) string
//}
type CustomDataLocation struct{}
func (d CustomDataLocation) DataDirectory() (string, error) {
// your custom implementation
}
func (d CustomDataLocation) LicenseFileName(productCode string) string {
// your custom implementation
}

config := license_client.NewLicenseClientConfigurationCustom(CustomCryptoProvider, CustomDataLocation, "apiKey", "sharedKey", "productCode")
client := license_client.NewLicenseClient(config)
﻿
Activate Key-Based License
After activating the license, this function saves the license file in the location specified by the DataLocation object. The file is securely encrypted using the implementation provided by the CryptoProvider.
Go
resp := client.ActivateLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Hostname:       "hostname",
	AppVersion:     "1.1.1",
	...
})
resp := client.ActivateLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Hostname:       "hostname",
	AppVersion:     "1.1.1",
	...
})
﻿
Activate User-Based License
After activating the license, this function saves the license file in the location specified by the DataLocation object. The file is securely encrypted using the implementation provided by the CryptoProvider.
Go
resp := client.ActivateLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromUsername("username", "password"),
	},
	Hostname:       "hostname",
	AppVersion:     "1.1.1",
	...
})
resp := client.ActivateLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromUsername("username", "password"),
	},
	Hostname:       "hostname",
	AppVersion:     "1.1.1",
	...
})
﻿
Deactivate Key-Based License
Go
err := client.DeactivateLicense(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
err := client.DeactivateLicense(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
﻿
Deactivate User-Based License
Go
err := client.DeactivateLicense(license_client.LicenseRequest{
	Auth: auth.FromUsername("username", "password"),
})
err := client.DeactivateLicense(license_client.LicenseRequest{
	Auth: auth.FromUsername("username", "password"),
})
﻿
Check Key-Based License
Go
resp := client.CheckLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	...
})
resp := client.CheckLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	...
})
﻿
Check User-Based License
Go
resp := client.CheckLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromUsername("username", "password"),
	},
	...
})
resp := client.CheckLicense(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromUsername("username", "password"),
	},
	...
})
﻿
Activate Offline License
After activating the license, this function saves the license file in the location specified by the DataLocation object. The file is securely encrypted using the implementation provided by the CryptoProvider.
Go
// Generate offline license request data
resp := client.GenerateOfflineLicenseRequest(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth:       auth.FromKey("licenseKey"),
	},
}, license_client.OfflineActivationRequest)

// Write to request file if you want to activate license manually
encoded, err := resp.Value.Encode()
ioutil.WriteFile("activate_offline.req", []byte(encoded), os.ModePerm)

// Activate offline license using API
client.ActivateOffline(offlineLicenseRequest)
// Generate offline license request data
resp := client.GenerateOfflineLicenseRequest(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth:       auth.FromKey("licenseKey"),
	},
}, license_client.OfflineActivationRequest)

// Write to request file if you want to activate license manually
encoded, err := resp.Value.Encode()
ioutil.WriteFile("activate_offline.req", []byte(encoded), os.ModePerm)

// Activate offline license using API
client.ActivateOffline(offlineLicenseRequest)
﻿
Deactivate Offline License
Go
// Generate offline license request data
resp := client.GenerateOfflineLicenseRequest(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth:       auth.FromKey("licenseKey"),
	},
}, license_client.OfflineDeactivationRequest)

// Write to request file if you want to deactivate license manually
encoded, err := resp.Value.Encode()
ioutil.WriteFile("deactivate_offline.req", []byte(encoded), os.ModePerm)

// Deactivate offline license using API
client.DeactivateOffline(offlineLicenseRequest)
// Generate offline license request data
resp := client.GenerateOfflineLicenseRequest(license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth:       auth.FromKey("licenseKey"),
	},
}, license_client.OfflineDeactivationRequest)

// Write to request file if you want to deactivate license manually
encoded, err := resp.Value.Encode()
ioutil.WriteFile("deactivate_offline.req", []byte(encoded), os.ModePerm)

// Deactivate offline license using API
client.DeactivateOffline(offlineLicenseRequest)
﻿
Local License Check
This function reads the license file from local memory, validates it by performing checks such as expiration and hardware ID matching, and returns the license object along with the results of these checks.
Go
clientConfig := license_client.NewLicenseClientConfiguration(
		config.ApiKey,
		config.SharedKey,
		productCode,
	)
clientConfig.Verbose = config.Verbose
clientConfig.VerifySignature = config.VerifySignature

client := license_client.NewLicenseClient(clientConfig)


resp := client.ActivateLicense(context.Background(), license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Product: productCode,
		Auth: auth.FromKey(productAuth.LicenseKey),
	},
})

resp2 := client.LocalLicenseCheck(context.Background(), 
license_client.LocalLicenseCheckRequest{Product: productCode})
clientConfig := license_client.NewLicenseClientConfiguration(
		config.ApiKey,
		config.SharedKey,
		productCode,
	)
clientConfig.Verbose = config.Verbose
clientConfig.VerifySignature = config.VerifySignature

client := license_client.NewLicenseClient(clientConfig)


resp := client.ActivateLicense(context.Background(), license_client.ActivationRequest{
	LicenseRequest: core_request.LicenseRequest{
		Product: productCode,
		Auth: auth.FromKey(productAuth.LicenseKey),
	},
})

resp2 := client.LocalLicenseCheck(context.Background(), 
license_client.LocalLicenseCheckRequest{Product: productCode})
﻿
Local license check returns an object of the following type:
Go
type LocalCheckResponse struct {
	LicenseResponse

	LicenseActive  bool `json:"license_active"`
	LicenseEnabled bool `json:"license_enabled"`
	IsExpired      bool `json:"is_expired"`

	DeviceLicensed bool `json:"is_device_licensed"`
	IsClockTampered  bool `json:"is_clock_tampered"`
	ProductMismatch bool `json:"product_mismatch"`
	FloatingExpired bool `json:"floating_expired"`
}
type LocalCheckResponse struct {
	LicenseResponse

	LicenseActive  bool `json:"license_active"`
	LicenseEnabled bool `json:"license_enabled"`
	IsExpired      bool `json:"is_expired"`

	DeviceLicensed bool `json:"is_device_licensed"`
	IsClockTampered  bool `json:"is_clock_tampered"`
	ProductMismatch bool `json:"product_mismatch"`
	FloatingExpired bool `json:"floating_expired"`
}
﻿
Add Consumption
Go

# Add 1 consumption
resp := client.AddConsumption(license_client.ConsumptionRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth:       auth.FromKey("licenseKey"),
	},
	Consumptions:   1,
})

# Add 1 consumption, allow overages and define max overages
resp := client.AddConsumption(license_client.ConsumptionRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Consumptions:  1,
	MaxOverages:   5,
	AllowOverages: true,
})

# Add 1 consumption
resp := client.AddConsumption(license_client.ConsumptionRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth:       auth.FromKey("licenseKey"),
	},
	Consumptions:   1,
})

# Add 1 consumption, allow overages and define max overages
resp := client.AddConsumption(license_client.ConsumptionRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Consumptions:  1,
	MaxOverages:   5,
	AllowOverages: true,
})
﻿
Add Feature Consumption
Go

resp := client.AddFeatureConsumption(license_client.FeatureConsumptionRequest{
	LicenseRequest: license_client.LicenseRequest{
		Auth: core_request.Auth{}.FromKey("licenseKey"),
	},
	Feature:        "featureCode",
	Consumptions:   1,
})

resp := client.AddFeatureConsumption(license_client.FeatureConsumptionRequest{
	LicenseRequest: license_client.LicenseRequest{
		Auth: core_request.Auth{}.FromKey("licenseKey"),
	},
	Feature:        "featureCode",
	Consumptions:   1,
})
﻿
Trial Key
Go
resp := client.TrialKey(license_client.TrialLicenseRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Email:          "",
	LicensePolicy:  "",
	FirstName:      "",
	LastName:       "",
	Phone:          "",
	Address:        "",
	PostCode:       "",
	State:          "",
	Country:        "",
	City:           "",
	Reference:      "",
})
resp := client.TrialKey(license_client.TrialLicenseRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Email:          "",
	LicensePolicy:  "",
	FirstName:      "",
	LastName:       "",
	Phone:          "",
	Address:        "",
	PostCode:       "",
	State:          "",
	Country:        "",
	City:           "",
	Reference:      "",
})
﻿
Product Details
Go

// takes product code from configuration
resp := client.ProductDetails()

// takes product code from configuration
resp := client.ProductDetails()
﻿
Track Device Variables
Go

err := client.TrackDeviceVariables(license_client.DeviceVariablesRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Variables: map[string]string{
		"key": "var",
	},
})

err := client.TrackDeviceVariables(license_client.DeviceVariablesRequest{
	LicenseRequest: core_request.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	Variables: map[string]string{
		"key": "var",
	},
})
﻿
Get Device Variables
Go
resp := client.GetDeviceVariables(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
resp := client.GetDeviceVariables(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
﻿
Floating Borrow
Go
resp := client.FloatingBorrow(license_client.FloatingBorrowRequest{
	LicenseRequest: license_client.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	BorrowedUntil:  time.Now().UTC().Add(time.Hour * 24 * 5),
})
resp := client.FloatingBorrow(license_client.FloatingBorrowRequest{
	LicenseRequest: license_client.LicenseRequest{
		Auth: auth.FromKey("licenseKey"),
	},
	BorrowedUntil:  time.Now().UTC().Add(time.Hour * 24 * 5),
})
﻿
Floating Release
Go
client.FloatingRelease(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
client.FloatingRelease(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
﻿
Change Password
Go
client.ChangePassword(license_client.ChangePasswordRequest{
	PasswordAuth: core_request.PasswordAuth{
		Username: "username",
		Password: "password",
	},
	NewPassword:  "abcd",
})
client.ChangePassword(license_client.ChangePasswordRequest{
	PasswordAuth: core_request.PasswordAuth{
		Username: "username",
		Password: "password",
	},
	NewPassword:  "abcd",
})
﻿
Versions
Go
resp := client.Versions(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
resp := client.Versions(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
﻿
Installation File
Go

resp := client.InstallationFile(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})

resp := client.InstallationFile(license_client.LicenseRequest{
	Auth: auth.FromKey("licenseKey"),
})
﻿
Customer License Users
Go
resp := client.CustomerLicenseUsers(license_client.CustomerLicenseUsersRequest{
	Customer: "customer",
})
resp := client.CustomerLicenseUsers(license_client.CustomerLicenseUsersRequest{
	Customer: "customer",
})
﻿
SSO URL
Go
resp := client.SSOUrl(license_client.SSOUrlRequest{
	CustomerAccountCode: "code",
})
resp := client.SSOUrl(license_client.SSOUrlRequest{
	CustomerAccountCode: "code",
})
﻿
Air-Gap Initialization
Go
airgapClient := license_client.NewAirgapClient(config, "publicKey")
activationCode, err := airgapClient.AirgapInitialization("licenseKey", "signingKey")
return activationCode, cfg.HardwareId
airgapClient := license_client.NewAirgapClient(config, "publicKey")
activationCode, err := airgapClient.AirgapInitialization("licenseKey", "signingKey")
return activationCode, cfg.HardwareId
﻿
Air-Gap Activation
Go
airgapClient := license_client.NewAirgapClient(config, "publicKey")
license, err := airgapClient.AirgapActivation("licensePolicy", "confirmationCode", 1234)
airgapClient := license_client.NewAirgapClient(config, "publicKey")
license, err := airgapClient.AirgapActivation("licensePolicy", "confirmationCode", 1234)
﻿
﻿
Common
Management Client