engrrajonahmed/aviorcli
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: engrrajonahmed:essential/file
Branches Tags
engrrajonahmed:main
engrrajonahmed:state/m1
engrrajonahmed:essential/file
engrrajonahmed:data/file
engrrajonahmed:root/file
..
compare: engrrajonahmed:main
Branches Tags
engrrajonahmed:state/m1
engrrajonahmed:essential/file
engrrajonahmed:data/file
engrrajonahmed:root/file
engrrajonahmed:main

No commits in common. "essential/file" and "main" have entirely different histories.
essential/ ... main

13 changed files with 0 additions and 6039 deletions
Show Stats Expand all files Collapse all files

514
essential/hidden/service/worker/clock/clock.go
View File

@ -1,514 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Clock
|
| Purpose:
| - Provides the clock synchronization service for maintaining a
| consistent system time reference across automation tasks.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package clock
import (
"encoding/binary"
"encoding/json"
"errors"
"net"
"os"
"path/filepath"
"runtime"
"sync"
"time"
)
const (
obrimClockSoftwareName = "obrim"
obrimClockNTPPort = 123
obrimClockNTPPacketSize = 48
obrimClockNTPVersion = 4
obrimClockNTPClientMode = 3
obrimClockNTPUnixOffset = 2208988800
obrimClockMaxRTT = 2 * time.Second
obrimClockSynchronizationInterval = 15 * time.Minute
obrimClockServerTimeout = 2 * time.Second
obrimClockSuccess = 0
obrimClockFailure = 1
)
var (
obrimClockMutex sync.RWMutex
obrimClockStop chan struct{}
obrimClockDone chan struct{}
obrimClockOffset int64
obrimClockLastSync int64
obrimClockStarted bool
)
// obrimClockConfig represents the persistent clock configuration.
type obrimClockConfig struct {
Clock *obrimClockState `json:"clock,omitempty"`
}
// obrimClockFile represents the persistent configuration document.
type obrimClockFile struct {
Config *obrimClockConfig `json:"config,omitempty"`
}
// obrimClockState represents the runtime and persistent synchronization state.
type obrimClockState struct {
ClockOffset int64 `json:"clockOffset"`
LastSync int64 `json:"lastSync"`
}
// obrimClockMeasurement represents one accepted or rejected NTP measurement.
type obrimClockMeasurement struct {
ServerTime time.Time
RequestTime time.Time
ResponseTime time.Time
RTT time.Duration
Offset time.Duration
Valid bool
}
// obrimClockResponse represents the timestamps extracted from an NTP response.
type obrimClockResponse struct {
ReceiveTimestamp uint64
TransmitTimestamp uint64
}
// ObrimClockStart starts the clock synchronization goroutine.
func ObrimClockStart() {
obrimClockMutex.Lock()
if obrimClockStarted {
obrimClockMutex.Unlock()
return
}
obrimClockStop = make(chan struct{})
obrimClockDone = make(chan struct{})
obrimClockStarted = true
obrimClockInitializeClock()
stop := obrimClockStop
done := obrimClockDone
obrimClockMutex.Unlock()
go func() {
defer close(done)
obrimClockSynchronizeClock()
ticker := time.NewTicker(obrimClockSynchronizationInterval)
defer ticker.Stop()
for {
select {
case <-ticker.C:
obrimClockSynchronizeClock()
case <-stop:
return
}
}
}()
}
// ObrimClockStop gracefully stops the clock synchronization goroutine.
func ObrimClockStop() {
obrimClockMutex.Lock()
if !obrimClockStarted {
obrimClockMutex.Unlock()
return
}
stop := obrimClockStop
done := obrimClockDone
obrimClockStop = nil
obrimClockDone = nil
obrimClockStarted = false
obrimClockMutex.Unlock()
close(stop)
<-done
}
// obrimClockInitializeClock initializes runtime clock state from persistent storage.
func obrimClockInitializeClock() {
state, result := obrimClockLoadClock()
obrimClockMutex.Lock()
defer obrimClockMutex.Unlock()
if result == obrimClockSuccess && state != nil {
obrimClockOffset = state.ClockOffset
obrimClockLastSync = state.LastSync
return
}
obrimClockOffset = 0
obrimClockLastSync = 0
_ = obrimClockPersistClock()
}
// obrimClockSynchronizeClock performs one NTP synchronization cycle.
func obrimClockSynchronizeClock() {
servers := []string{
"time.cloudflare.com",
"time.google.com",
"pool.ntp.org",
}
measurements := make([]obrimClockMeasurement, 0, len(servers))
for _, server := range servers {
measurement, result := obrimClockQueryServer(server)
if result != obrimClockSuccess {
continue
}
if obrimClockMeasureDelay(&measurement) != obrimClockSuccess {
continue
}
if obrimClockCalculateOffset(&measurement) != obrimClockSuccess {
continue
}
if obrimClockValidateMeasurement(&measurement) != obrimClockSuccess {
continue
}
measurements = append(measurements, measurement)
}
if len(measurements) == 0 {
return
}
offset, result := obrimClockCalculateAverageOffset(measurements)
if result != obrimClockSuccess {
return
}
clockOffset := offset.Nanoseconds()
lastSync := time.Now().UnixNano()
obrimClockUpdateClock(clockOffset, lastSync)
_ = obrimClockPersistClock()
}
// obrimClockQueryServer sends an NTP request and receives a server response.
func obrimClockQueryServer(server string) (obrimClockMeasurement, int) {
var measurement obrimClockMeasurement
address := net.JoinHostPort(server, "123")
connection, err := net.DialTimeout("udp", address, obrimClockServerTimeout)
if err != nil {
return measurement, obrimClockFailure
}
defer connection.Close()
request := make([]byte, obrimClockNTPPacketSize)
request[0] = (obrimClockNTPVersion << 3) | obrimClockNTPClientMode
requestTime := time.Now()
if _, err := connection.Write(request); err != nil {
return measurement, obrimClockFailure
}
if err := connection.SetReadDeadline(time.Now().Add(obrimClockServerTimeout)); err != nil {
return measurement, obrimClockFailure
}
response := make([]byte, obrimClockNTPPacketSize)
if _, err := connection.Read(response); err != nil {
return measurement, obrimClockFailure
}
responseTime := time.Now()
if len(response) < obrimClockNTPPacketSize {
return measurement, obrimClockFailure
}
receiveTimestamp := binary.BigEndian.Uint64(response[32:40])
transmitTimestamp := binary.BigEndian.Uint64(response[40:48])
if transmitTimestamp == 0 {
return measurement, obrimClockFailure
}
serverTime, err := obrimClockNTPToTime(transmitTimestamp)
if err != nil {
return measurement, obrimClockFailure
}
measurement = obrimClockMeasurement{
ServerTime: serverTime,
RequestTime: requestTime,
ResponseTime: responseTime,
}
_ = receiveTimestamp
return measurement, obrimClockSuccess
}
// obrimClockMeasureDelay calculates network round-trip time.
func obrimClockMeasureDelay(measurement *obrimClockMeasurement) int {
if measurement == nil {
return obrimClockFailure
}
if measurement.ResponseTime.Before(measurement.RequestTime) {
return obrimClockFailure
}
measurement.RTT = measurement.ResponseTime.Sub(measurement.RequestTime)
if measurement.RTT <= 0 || measurement.RTT > obrimClockMaxRTT {
return obrimClockFailure
}
return obrimClockSuccess
}
// obrimClockCalculateOffset calculates the local clock offset from an NTP response.
func obrimClockCalculateOffset(measurement *obrimClockMeasurement) int {
if measurement == nil {
return obrimClockFailure
}
midpoint := measurement.RequestTime.Add(measurement.RTT / 2)
measurement.Offset = measurement.ServerTime.Sub(midpoint)
return obrimClockSuccess
}
// obrimClockValidateMeasurement validates an NTP synchronization measurement.
func obrimClockValidateMeasurement(measurement *obrimClockMeasurement) int {
if measurement == nil {
return obrimClockFailure
}
if measurement.RTT <= 0 || measurement.RTT > obrimClockMaxRTT {
return obrimClockFailure
}
if measurement.ServerTime.IsZero() {
return obrimClockFailure
}
if measurement.RequestTime.IsZero() || measurement.ResponseTime.IsZero() {
return obrimClockFailure
}
if measurement.ResponseTime.Before(measurement.RequestTime) {
return obrimClockFailure
}
measurement.Valid = true
return obrimClockSuccess
}
// obrimClockCalculateAverageOffset calculates the trusted average clock offset.
func obrimClockCalculateAverageOffset(measurements []obrimClockMeasurement) (time.Duration, int) {
var total int64
var count int64
for _, measurement := range measurements {
if !measurement.Valid {
continue
}
total += measurement.Offset.Nanoseconds()
count++
}
if count == 0 {
return 0, obrimClockFailure
}
return time.Duration(total / count), obrimClockSuccess
}
// obrimClockUpdateClock updates the runtime clock state.
func obrimClockUpdateClock(clockOffset int64, lastSync int64) {
obrimClockMutex.Lock()
defer obrimClockMutex.Unlock()
obrimClockOffset = clockOffset
obrimClockLastSync = lastSync
}
// obrimClockPersistClock writes the runtime clock state to persistent storage.
func obrimClockPersistClock() int {
obrimClockMutex.RLock()
state := obrimClockState{
ClockOffset: obrimClockOffset,
LastSync: obrimClockLastSync,
}
obrimClockMutex.RUnlock()
configPath, err := obrimClockConfigPath()
if err != nil {
return obrimClockFailure
}
data, err := os.ReadFile(configPath)
if err != nil {
if errors.Is(err, os.ErrNotExist) {
return obrimClockFailure
}
return obrimClockFailure
}
var document obrimClockFile
if len(data) != 0 {
if err := json.Unmarshal(data, &document); err != nil {
return obrimClockFailure
}
}
if document.Config == nil {
document.Config = &obrimClockConfig{}
}
document.Config.Clock = &state
updatedData, err := json.MarshalIndent(document, "", " ")
if err != nil {
return obrimClockFailure
}
if err := os.WriteFile(configPath, updatedData, 0644); err != nil {
return obrimClockFailure
}
return obrimClockSuccess
}
// obrimClockCurrentClock returns the current synchronized UTC.
func obrimClockCurrentClock() time.Time {
obrimClockMutex.RLock()
offset := obrimClockOffset
obrimClockMutex.RUnlock()
return time.Now().UTC().Add(time.Duration(offset))
}
// obrimClockLoadClock loads the persisted clock state.
func obrimClockLoadClock() (*obrimClockState, int) {
configPath, err := obrimClockConfigPath()
if err != nil {
return nil, obrimClockFailure
}
data, err := os.ReadFile(configPath)
if err != nil {
return nil, obrimClockFailure
}
var document obrimClockFile
if err := json.Unmarshal(data, &document); err != nil {
return nil, obrimClockFailure
}
if document.Config == nil || document.Config.Clock == nil {
return nil, obrimClockFailure
}
return document.Config.Clock, obrimClockSuccess
}
// obrimClockConfigPath returns the platform-specific persistent configuration path.
func obrimClockConfigPath() (string, error) {
var basePath string
switch runtime.GOOS {
case "windows":
basePath = os.Getenv("APPDATA")
if basePath == "" {
return "", errors.New("APPDATA is not defined")
}
case "darwin":
homePath, err := os.UserHomeDir()
if err != nil {
return "", err
}
basePath = filepath.Join(homePath, "Library", "Application Support")
default:
homePath, err := os.UserHomeDir()
if err != nil {
return "", err
}
basePath = filepath.Join(homePath, ".config")
}
return filepath.Join(
basePath,
obrimClockSoftwareName,
"persistent",
"config",
"config.json",
), nil
}
// obrimClockNTPToTime converts an NTP timestamp into Unix UTC time.
func obrimClockNTPToTime(timestamp uint64) (time.Time, error) {
seconds := timestamp >> 32
fraction := timestamp & 0xffffffff
if seconds < obrimClockNTPUnixOffset {
return time.Time{}, errors.New("invalid NTP timestamp")
}
unixSeconds := int64(seconds) - obrimClockNTPUnixOffset
nanoseconds := int64((fraction * 1_000_000_000) >> 32)
return time.Unix(unixSeconds, nanoseconds).UTC(), nil
}

57
essential/hidden/service/worker/manager/manager.go
View File

@ -1,57 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Manager
|
| Purpose:
| - Provides the clock synchronization service for maintaining a
| consistent system time reference across automation tasks.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package manager
import (
"go/module/essential/hidden/service/worker/clock"
// Import more workers as needed.
)
// ObrimWorkerManagerAction defines a worker manager action.
type ObrimWorkerManagerAction string
const (
// ObrimWorkerManagerActionStart starts all framework workers.
ObrimWorkerManagerActionStart ObrimWorkerManagerAction = "start"
// ObrimWorkerManagerActionStop stops all framework workers.
ObrimWorkerManagerActionStop ObrimWorkerManagerAction = "stop"
)
// ObrimWorkerManager starts or stops all framework workers.
func ObrimWorkerManager(action ObrimWorkerManagerAction) {
switch action {
case ObrimWorkerManagerActionStart:
clock.ObrimClockStart()
// Add more worker start functions as needed.
case ObrimWorkerManagerActionStop:
clock.ObrimClockStop()
// Add more worker stop functions as needed.
}
}

641
essential/visible/service/helper/cipher/cipher.go
View File

@ -1,641 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Cipher
|
| Purpose:
| - Provide reusable AES-256 encryption and decryption for file content.
| - Support standard and salted encryption formats through a unified interface.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use encrypt-standard to encrypt file content using AES-256 without salt.
| - Use encrypt-salted to encrypt file content using AES-256 with a cryptographically secure generated salt.
| - Use decrypt-standard to decrypt AES-256 encrypted file content without salt metadata.
| - Use decrypt-salted to decrypt self-contained encrypted files with embedded signature, version, salt, and ciphertext metadata.
| - Supply the AES-256 compatible key, input file path, and output file path through the configuration.
|
| Example:
| - ObrimCipher("encrypt-standard", map[string]any{
| "key": key,
| "input": inputPath,
| "output": outputPath,
| })
|
| - ObrimCipher("encrypt-salted", map[string]any{
| "key": key,
| "input": inputPath,
| "output": outputPath,
| })
|
| - ObrimCipher("decrypt-standard", map[string]any{
| "key": key,
| "input": inputPath,
| "output": outputPath,
| })
|
| - ObrimCipher("decrypt-salted", map[string]any{
| "key": key,
| "input": inputPath,
| "output": outputPath,
| })
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package cipher
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"crypto/sha256"
"errors"
"fmt"
"os"
"path/filepath"
)
// Utility execution type identifiers.
const (
obrimCipherTypeEncryptStandard = "encrypt-standard"
obrimCipherTypeEncryptSalted = "encrypt-salted"
obrimCipherTypeDecryptStandard = "decrypt-standard"
obrimCipherTypeDecryptSalted = "decrypt-salted"
)
// Cipher format metadata values.
const (
obrimCipherAlgorithm = "AES-256-GCM"
obrimCipherFormat = "OBRIM-CIPHER"
obrimCipherVersion = "1"
obrimCipherSaltSize = 32
)
// Utility execution success result codes.
const (
obrimCipherSuccessEncryptStandard = "SUCCESS_ENCRYPT_STANDARD"
obrimCipherSuccessEncryptSalted = "SUCCESS_ENCRYPT_SALTED"
obrimCipherSuccessDecryptStandard = "SUCCESS_DECRYPT_STANDARD"
obrimCipherSuccessDecryptSalted = "SUCCESS_DECRYPT_SALTED"
)
// Utility execution failure result codes.
const (
obrimCipherFailureInvalidType = "FAILURE_INVALID_TYPE"
obrimCipherFailureInvalidConfig = "FAILURE_INVALID_CONFIG"
obrimCipherFailureMissingKey = "FAILURE_MISSING_KEY"
obrimCipherFailureInvalidKey = "FAILURE_INVALID_KEY"
obrimCipherFailureMissingInput = "FAILURE_MISSING_INPUT"
obrimCipherFailureInvalidInput = "FAILURE_INVALID_INPUT"
obrimCipherFailureMissingOutput = "FAILURE_MISSING_OUTPUT"
obrimCipherFailureInvalidOutput = "FAILURE_INVALID_OUTPUT"
obrimCipherFailureExternalSalt = "FAILURE_EXTERNAL_SALT"
obrimCipherFailureReadInput = "FAILURE_READ_INPUT"
obrimCipherFailureWriteOutput = "FAILURE_WRITE_OUTPUT"
obrimCipherFailureCipherInitialization = "FAILURE_CIPHER_INITIALIZATION"
obrimCipherFailureNonceGeneration = "FAILURE_NONCE_GENERATION"
obrimCipherFailureEncryption = "FAILURE_ENCRYPTION"
obrimCipherFailureDecryption = "FAILURE_DECRYPTION"
obrimCipherFailureSaltGeneration = "FAILURE_SALT_GENERATION"
obrimCipherFailureHeaderBuild = "FAILURE_HEADER_BUILD"
obrimCipherFailureSignature = "FAILURE_INVALID_SIGNATURE"
obrimCipherFailureVersion = "FAILURE_INVALID_VERSION"
obrimCipherFailureSaltExtraction = "FAILURE_SALT_EXTRACTION"
obrimCipherFailurePayloadExtraction = "FAILURE_PAYLOAD_EXTRACTION"
)
// Standardized utility output.
type obrimCipherOutput struct {
Status bool
Code string
Payload any
}
// Salted encrypted file header.
type obrimCipherHeader struct {
Signature []byte
Version []byte
Salt []byte
}
// Standardized operation payload.
type obrimCipherPayload struct {
Operation string
Algorithm string
Format string
Version string
InputPath string
OutputPath string
}
// ObrimCipher executes encryption or decryption operations through a unified interface.
func ObrimCipher(typeName string, config map[string]any) map[string]any {
if code := obrimCipherValidateInput(typeName, config); code != "" {
return obrimCipherBuildOutput(false, code, nil)
}
payload, code := obrimCipherRouteRequest(typeName, config)
if code != "" {
return obrimCipherBuildOutput(false, code, nil)
}
return obrimCipherBuildOutput(true, code, payload)
}
// obrimCipherValidateInput validates the requested operation and its configuration.
func obrimCipherValidateInput(typeName string, config map[string]any) string {
switch typeName {
case obrimCipherTypeEncryptStandard,
obrimCipherTypeEncryptSalted,
obrimCipherTypeDecryptStandard,
obrimCipherTypeDecryptSalted:
default:
return obrimCipherFailureInvalidType
}
if config == nil {
return obrimCipherFailureInvalidConfig
}
key, ok := config["key"]
if !ok || key == nil {
return obrimCipherFailureMissingKey
}
if !obrimCipherValidKey(key) {
return obrimCipherFailureInvalidKey
}
input, ok := config["input"]
if !ok || input == nil {
return obrimCipherFailureMissingInput
}
inputPath, ok := input.(string)
if !ok || inputPath == "" {
return obrimCipherFailureInvalidInput
}
output, ok := config["output"]
if !ok || output == nil {
return obrimCipherFailureMissingOutput
}
outputPath, ok := output.(string)
if !ok || outputPath == "" {
return obrimCipherFailureInvalidOutput
}
switch typeName {
case obrimCipherTypeEncryptSalted, obrimCipherTypeDecryptSalted:
if _, exists := config["salt"]; exists {
return obrimCipherFailureExternalSalt
}
}
return ""
}
// obrimCipherRouteRequest routes a validated request to its operation-specific implementation.
func obrimCipherRouteRequest(typeName string, config map[string]any) (map[string]any, string) {
switch typeName {
case obrimCipherTypeEncryptStandard:
return obrimCipherEncryptStandard(config)
case obrimCipherTypeEncryptSalted:
return obrimCipherEncryptSalted(config)
case obrimCipherTypeDecryptStandard:
return obrimCipherDecryptStandard(config)
case obrimCipherTypeDecryptSalted:
return obrimCipherDecryptSalted(config)
default:
return nil, obrimCipherFailureInvalidType
}
}
// obrimCipherBuildOutput builds the standardized utility output.
func obrimCipherBuildOutput(status bool, code string, payload map[string]any) map[string]any {
return map[string]any{
"status": status,
"code": code,
"payload": payload,
}
}
// obrimCipherEncryptStandard encrypts file content without salt metadata.
func obrimCipherEncryptStandard(config map[string]any) (map[string]any, string) {
key, ok := obrimCipherKey(config["key"])
if !ok {
return nil, obrimCipherFailureInvalidKey
}
inputPath, outputPath, ok := obrimCipherPaths(config)
if !ok {
return nil, obrimCipherFailureInvalidConfig
}
plaintext, err := os.ReadFile(inputPath)
if err != nil {
return nil, obrimCipherFailureReadInput
}
ciphertext, code := obrimCipherEncrypt(key, plaintext, nil)
if code != "" {
return nil, code
}
if err := os.WriteFile(outputPath, ciphertext, 0600); err != nil {
return nil, obrimCipherFailureWriteOutput
}
return map[string]any{
"operation": obrimCipherTypeEncryptStandard,
"algorithm": obrimCipherAlgorithm,
"inputPath": inputPath,
"outputPath": outputPath,
}, obrimCipherSuccessEncryptStandard
}
// obrimCipherGenerateSalt generates a cryptographically secure salt.
func obrimCipherGenerateSalt() ([]byte, string) {
salt := make([]byte, obrimCipherSaltSize)
if _, err := rand.Read(salt); err != nil {
return nil, obrimCipherFailureSaltGeneration
}
return salt, ""
}
// obrimCipherBuildHeader builds the salted cipher signature, version, and salt header.
func obrimCipherBuildHeader(salt []byte) ([]byte, string) {
if len(salt) != obrimCipherSaltSize {
return nil, obrimCipherFailureHeaderBuild
}
signature := []byte(obrimCipherFormat)
version := []byte(obrimCipherVersion)
header := make([]byte, 0, len(signature)+len(version)+len(salt))
header = append(header, signature...)
header = append(header, version...)
header = append(header, salt...)
return header, ""
}
// obrimCipherEncryptSalted encrypts file content with embedded salt metadata.
func obrimCipherEncryptSalted(config map[string]any) (map[string]any, string) {
key, ok := obrimCipherKey(config["key"])
if !ok {
return nil, obrimCipherFailureInvalidKey
}
inputPath, outputPath, ok := obrimCipherPaths(config)
if !ok {
return nil, obrimCipherFailureInvalidConfig
}
plaintext, err := os.ReadFile(inputPath)
if err != nil {
return nil, obrimCipherFailureReadInput
}
salt, code := obrimCipherGenerateSalt()
if code != "" {
return nil, code
}
header, code := obrimCipherBuildHeader(salt)
if code != "" {
return nil, code
}
ciphertext, code := obrimCipherEncrypt(key, plaintext, salt)
if code != "" {
return nil, code
}
output := make([]byte, 0, len(header)+len(ciphertext))
output = append(output, header...)
output = append(output, ciphertext...)
if err := os.WriteFile(outputPath, output, 0600); err != nil {
return nil, obrimCipherFailureWriteOutput
}
return map[string]any{
"operation": obrimCipherTypeEncryptSalted,
"algorithm": obrimCipherAlgorithm,
"format": obrimCipherFormat,
"version": obrimCipherVersion,
"inputPath": inputPath,
"outputPath": outputPath,
}, obrimCipherSuccessEncryptSalted
}
// obrimCipherDecryptStandard decrypts file content without salt metadata.
func obrimCipherDecryptStandard(config map[string]any) (map[string]any, string) {
key, ok := obrimCipherKey(config["key"])
if !ok {
return nil, obrimCipherFailureInvalidKey
}
inputPath, outputPath, ok := obrimCipherPaths(config)
if !ok {
return nil, obrimCipherFailureInvalidConfig
}
ciphertext, err := os.ReadFile(inputPath)
if err != nil {
return nil, obrimCipherFailureReadInput
}
plaintext, code := obrimCipherDecrypt(key, ciphertext, nil)
if code != "" {
return nil, code
}
if err := os.WriteFile(outputPath, plaintext, 0600); err != nil {
return nil, obrimCipherFailureWriteOutput
}
return map[string]any{
"operation": obrimCipherTypeDecryptStandard,
"algorithm": obrimCipherAlgorithm,
"inputPath": inputPath,
"outputPath": outputPath,
}, obrimCipherSuccessDecryptStandard
}
// obrimCipherParseHeader parses the signature and version metadata.
func obrimCipherParseHeader(data []byte) (obrimCipherHeader, string) {
signatureLength := len(obrimCipherFormat)
versionLength := len(obrimCipherVersion)
minimumLength := signatureLength + versionLength + obrimCipherSaltSize
if len(data) < minimumLength {
return obrimCipherHeader{}, obrimCipherFailureSignature
}
signature := data[:signatureLength]
if string(signature) != obrimCipherFormat {
return obrimCipherHeader{}, obrimCipherFailureSignature
}
versionStart := signatureLength
versionEnd := versionStart + versionLength
version := data[versionStart:versionEnd]
if string(version) != obrimCipherVersion {
return obrimCipherHeader{}, obrimCipherFailureVersion
}
saltStart := versionEnd
saltEnd := saltStart + obrimCipherSaltSize
return obrimCipherHeader{
Signature: append([]byte(nil), signature...),
Version: append([]byte(nil), version...),
Salt: append([]byte(nil), data[saltStart:saltEnd]...),
}, ""
}
// obrimCipherExtractSalt extracts the embedded salt from a parsed salted file.
func obrimCipherExtractSalt(data []byte, header obrimCipherHeader) ([]byte, string) {
if len(header.Salt) != obrimCipherSaltSize {
return nil, obrimCipherFailureSaltExtraction
}
signatureLength := len(header.Signature)
versionLength := len(header.Version)
saltStart := signatureLength + versionLength
saltEnd := saltStart + obrimCipherSaltSize
if saltStart < 0 || saltEnd > len(data) {
return nil, obrimCipherFailureSaltExtraction
}
return append([]byte(nil), data[saltStart:saltEnd]...), ""
}
// obrimCipherExtractPayload extracts the encrypted payload after the salted header.
func obrimCipherExtractPayload(data []byte, header obrimCipherHeader) ([]byte, string) {
payloadStart := len(header.Signature) + len(header.Version) + len(header.Salt)
if payloadStart >= len(data) {
return nil, obrimCipherFailurePayloadExtraction
}
payload := data[payloadStart:]
if len(payload) <= 0 {
return nil, obrimCipherFailurePayloadExtraction
}
return append([]byte(nil), payload...), ""
}
// obrimCipherDecryptSalted decrypts file content using its embedded salt metadata.
func obrimCipherDecryptSalted(config map[string]any) (map[string]any, string) {
key, ok := obrimCipherKey(config["key"])
if !ok {
return nil, obrimCipherFailureInvalidKey
}
inputPath, outputPath, ok := obrimCipherPaths(config)
if !ok {
return nil, obrimCipherFailureInvalidConfig
}
data, err := os.ReadFile(inputPath)
if err != nil {
return nil, obrimCipherFailureReadInput
}
header, code := obrimCipherParseHeader(data)
if code != "" {
return nil, code
}
salt, code := obrimCipherExtractSalt(data, header)
if code != "" {
return nil, code
}
payload, code := obrimCipherExtractPayload(data, header)
if code != "" {
return nil, code
}
plaintext, code := obrimCipherDecrypt(key, payload, salt)
if code != "" {
return nil, code
}
if err := os.WriteFile(outputPath, plaintext, 0600); err != nil {
return nil, obrimCipherFailureWriteOutput
}
return map[string]any{
"operation": obrimCipherTypeDecryptSalted,
"algorithm": obrimCipherAlgorithm,
"format": string(header.Signature),
"version": string(header.Version),
"inputPath": inputPath,
"outputPath": outputPath,
}, obrimCipherSuccessDecryptSalted
}
// obrimCipherEncrypt performs AES-256-GCM encryption and prefixes the nonce to the ciphertext.
func obrimCipherEncrypt(key []byte, plaintext []byte, salt []byte) ([]byte, string) {
derivedKey := obrimCipherDeriveKey(key, salt)
block, err := aes.NewCipher(derivedKey)
if err != nil {
return nil, obrimCipherFailureCipherInitialization
}
aead, err := cipher.NewGCM(block)
if err != nil {
return nil, obrimCipherFailureCipherInitialization
}
nonce := make([]byte, aead.NonceSize())
if _, err := rand.Read(nonce); err != nil {
return nil, obrimCipherFailureNonceGeneration
}
ciphertext := aead.Seal(nil, nonce, plaintext, nil)
output := make([]byte, 0, len(nonce)+len(ciphertext))
output = append(output, nonce...)
output = append(output, ciphertext...)
return output, ""
}
// obrimCipherDecrypt performs AES-256-GCM decryption after extracting the nonce.
func obrimCipherDecrypt(key []byte, ciphertext []byte, salt []byte) ([]byte, string) {
derivedKey := obrimCipherDeriveKey(key, salt)
block, err := aes.NewCipher(derivedKey)
if err != nil {
return nil, obrimCipherFailureCipherInitialization
}
aead, err := cipher.NewGCM(block)
if err != nil {
return nil, obrimCipherFailureCipherInitialization
}
nonceSize := aead.NonceSize()
if len(ciphertext) <= nonceSize {
return nil, obrimCipherFailureDecryption
}
nonce := ciphertext[:nonceSize]
payload := ciphertext[nonceSize:]
plaintext, err := aead.Open(nil, nonce, payload, nil)
if err != nil {
return nil, obrimCipherFailureDecryption
}
return plaintext, ""
}
// obrimCipherDeriveKey derives the AES-256 key from the supplied key and optional salt.
func obrimCipherDeriveKey(key []byte, salt []byte) []byte {
if len(salt) == 0 {
return append([]byte(nil), key...)
}
digest := sha256.New()
_, _ = digest.Write(key)
_, _ = digest.Write(salt)
return digest.Sum(nil)
}
// obrimCipherKey normalizes a supported AES-256 key value.
func obrimCipherKey(value any) ([]byte, bool) {
switch key := value.(type) {
case string:
if len([]byte(key)) != 32 {
return nil, false
}
return []byte(key), true
case []byte:
if len(key) != 32 {
return nil, false
}
return append([]byte(nil), key...), true
default:
return nil, false
}
}
// obrimCipherValidKey validates that a supplied key is AES-256 compatible.
func obrimCipherValidKey(value any) bool {
_, ok := obrimCipherKey(value)
return ok
}
// obrimCipherPaths resolves and validates the configured input and output paths.
func obrimCipherPaths(config map[string]any) (string, string, bool) {
input, inputOK := config["input"].(string)
output, outputOK := config["output"].(string)
if !inputOK || !outputOK || input == "" || output == "" {
return "", "", false
}
inputPath, err := filepath.Abs(input)
if err != nil {
return "", "", false
}
outputPath, err := filepath.Abs(output)
if err != nil {
return "", "", false
}
if inputPath == outputPath {
return "", "", false
}
if _, err := os.Stat(inputPath); err != nil {
return "", "", false
}
return inputPath, outputPath, true
}
// obrimCipherError provides a deterministic error representation for internal callers.
func obrimCipherError(code string) error {
return errors.New(fmt.Sprintf("cipher: %s", code))
}

689
essential/visible/service/helper/codec/codec.go
View File

@ -1,689 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Codec
|
| Purpose:
| - Provide unified encoding and decoding capabilities using Base8,
| Base10, Base16, Base32, Base64, and Sqids with centralized
| validation, operation dispatching, transformation handling,
| and standardized result generation.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use the utility to encode input data using the selected codec format.
| - Use the utility to decode input data using the selected codec format.
| - Configure the codec format using base8, base10, base16, base32,
| base64, or sqids.
| - Provide input data as a string or []byte.
| - Configure charset and salt transformations when required.
| - Configure lower or upper output casing when required.
| - Configure minimum output length for Sqids encoding.
| - Configure length for deterministic Sqids decoding.
|
| Example:
| - ObrimCodec("encode", map[string]any{
| "format": "base64",
| "data": "hello",
| })
|
| - ObrimCodec("decode", map[string]any{
| "format": "base64",
| "data": "aGVsbG8=",
| })
|
| - ObrimCodec("encode", map[string]any{
| "format": "sqids",
| "data": "12345",
| "charset": "abcdefghijklmnopqrstuvwxyz",
| "salt": "example",
| "length": 8,
| })
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package codec
import (
"bytes"
"encoding/base32"
"encoding/base64"
"encoding/hex"
"encoding/json"
"fmt"
"math/big"
"strings"
"github.com/sqids/sqids-go"
)
const (
obrimCodecTypeEncode = "encode"
obrimCodecTypeDecode = "decode"
obrimCodecFormatBase8 = "base8"
obrimCodecFormatBase10 = "base10"
obrimCodecFormatBase16 = "base16"
obrimCodecFormatBase32 = "base32"
obrimCodecFormatBase64 = "base64"
obrimCodecFormatSqids = "sqids"
obrimCodecCaseLower = "lower"
obrimCodecCaseUpper = "upper"
obrimCodecSuccessEncoded = "SUCCESS_ENCODED"
obrimCodecSuccessDecoded = "SUCCESS_DECODED"
obrimCodecFailureInvalidType = "FAILURE_INVALID_TYPE"
obrimCodecFailureInvalidConfig = "FAILURE_INVALID_CONFIG"
obrimCodecFailureInvalidFormat = "FAILURE_INVALID_FORMAT"
obrimCodecFailureInvalidData = "FAILURE_INVALID_DATA"
obrimCodecFailureInvalidCharset = "FAILURE_INVALID_CHARSET"
obrimCodecFailureInvalidSalt = "FAILURE_INVALID_SALT"
obrimCodecFailureInvalidCase = "FAILURE_INVALID_CASE"
obrimCodecFailureInvalidLength = "FAILURE_INVALID_LENGTH"
obrimCodecFailureEncoding = "FAILURE_ENCODING"
obrimCodecFailureDecoding = "FAILURE_DECODING"
obrimCodecFailureTransformation = "FAILURE_TRANSFORMATION"
obrimCodecFailureTransformationReversal = "FAILURE_TRANSFORMATION_REVERSAL"
obrimCodecFailureUnsupportedData = "FAILURE_UNSUPPORTED_DATA"
obrimCodecFailureSqids = "FAILURE_SQIDS"
)
type obrimCodecConfig struct {
format string
data []byte
charset string
salt string
caseRule string
length int
}
type obrimCodecResult struct {
operation string
format string
value string
}
type obrimCodecOutput struct {
Status bool `json:"status"`
Code string `json:"code"`
Payload *obrimCodecResult `json:"payload"`
}
func ObrimCodec(typ string, config map[string]any) map[string]any {
normalized, code := obrimCodecValidateInput(typ, config)
if code != "" {
return obrimCodecBuildOutput(false, code, nil)
}
value, code := obrimCodecRouteRequest(typ, normalized)
if code != "" {
return obrimCodecBuildOutput(false, code, nil)
}
if typ == obrimCodecTypeEncode {
return obrimCodecBuildOutput(
true,
obrimCodecSuccessEncoded,
&obrimCodecResult{
operation: typ,
format: normalized.format,
value: value,
},
)
}
return obrimCodecBuildOutput(
true,
obrimCodecSuccessDecoded,
&obrimCodecResult{
operation: typ,
format: normalized.format,
value: value,
},
)
}
func obrimCodecValidateInput(typ string, config map[string]any) (obrimCodecConfig, string) {
var result obrimCodecConfig
switch typ {
case obrimCodecTypeEncode, obrimCodecTypeDecode:
default:
return result, obrimCodecFailureInvalidType
}
formatValue, exists := config["format"]
if !exists {
return result, obrimCodecFailureInvalidConfig
}
format, ok := formatValue.(string)
if !ok || format == "" {
return result, obrimCodecFailureInvalidFormat
}
switch format {
case obrimCodecFormatBase8,
obrimCodecFormatBase10,
obrimCodecFormatBase16,
obrimCodecFormatBase32,
obrimCodecFormatBase64,
obrimCodecFormatSqids:
default:
return result, obrimCodecFailureInvalidFormat
}
dataValue, exists := config["data"]
if !exists {
return result, obrimCodecFailureInvalidData
}
switch value := dataValue.(type) {
case string:
if value == "" {
return result, obrimCodecFailureInvalidData
}
result.data = []byte(value)
case []byte:
if len(value) == 0 {
return result, obrimCodecFailureInvalidData
}
result.data = append([]byte(nil), value...)
default:
return result, obrimCodecFailureUnsupportedData
}
result.format = format
if charsetValue, exists := config["charset"]; exists {
charset, ok := charsetValue.(string)
if !ok || charset == "" {
return result, obrimCodecFailureInvalidCharset
}
result.charset = charset
}
if saltValue, exists := config["salt"]; exists {
salt, ok := saltValue.(string)
if !ok || salt == "" {
return result, obrimCodecFailureInvalidSalt
}
result.salt = salt
}
if caseValue, exists := config["case"]; exists {
caseRule, ok := caseValue.(string)
if !ok {
return result, obrimCodecFailureInvalidCase
}
switch caseRule {
case obrimCodecCaseLower, obrimCodecCaseUpper:
result.caseRule = caseRule
default:
return result, obrimCodecFailureInvalidCase
}
}
if lengthValue, exists := config["length"]; exists {
switch length := lengthValue.(type) {
case int:
result.length = length
case int8:
result.length = int(length)
case int16:
result.length = int(length)
case int32:
result.length = int(length)
case int64:
result.length = int(length)
case uint:
result.length = int(length)
case uint8:
result.length = int(length)
case uint16:
result.length = int(length)
case uint32:
result.length = int(length)
case uint64:
if uint64(int(length)) != length {
return result, obrimCodecFailureInvalidLength
}
result.length = int(length)
case float64:
if length != float64(int(length)) {
return result, obrimCodecFailureInvalidLength
}
result.length = int(length)
default:
return result, obrimCodecFailureInvalidLength
}
if result.length < 0 {
return result, obrimCodecFailureInvalidLength
}
}
if format == obrimCodecFormatSqids && result.length == 0 {
result.length = 0
}
return result, ""
}
func obrimCodecRouteRequest(typ string, config obrimCodecConfig) (string, string) {
switch typ {
case obrimCodecTypeEncode:
return obrimCodecEncode(config)
case obrimCodecTypeDecode:
return obrimCodecDecode(config)
default:
return "", obrimCodecFailureInvalidType
}
}
func obrimCodecBuildOutput(status bool, code string, payload *obrimCodecResult) map[string]any {
if !status {
return map[string]any{
"status": false,
"code": code,
"payload": nil,
}
}
return map[string]any{
"status": true,
"code": code,
"payload": map[string]any{
"operation": payload.operation,
"format": payload.format,
"value": payload.value,
},
}
}
func obrimCodecEncode(config obrimCodecConfig) (string, string) {
data, code := obrimCodecApplyEncodeTransformations(config.data, config)
if code != "" {
return "", code
}
var (
value string
err error
)
switch config.format {
case obrimCodecFormatBase8:
value, err = obrimCodecEncodeBase8(data)
case obrimCodecFormatBase10:
value, err = obrimCodecEncodeBase10(data)
case obrimCodecFormatBase16:
value, err = obrimCodecEncodeBase16(data)
case obrimCodecFormatBase32:
value, err = obrimCodecEncodeBase32(data)
case obrimCodecFormatBase64:
value, err = obrimCodecEncodeBase64(data)
case obrimCodecFormatSqids:
value, err = obrimCodecEncodeSqids(data, config)
default:
return "", obrimCodecFailureInvalidFormat
}
if err != nil {
if config.format == obrimCodecFormatSqids {
return "", obrimCodecFailureSqids
}
return "", obrimCodecFailureEncoding
}
value = obrimCodecApplyCase(value, config.caseRule)
return value, ""
}
func obrimCodecDecode(config obrimCodecConfig) (string, string) {
data := append([]byte(nil), config.data...)
var err error
var value []byte
switch config.format {
case obrimCodecFormatBase8:
value, err = obrimCodecDecodeBase8(string(data))
case obrimCodecFormatBase10:
value, err = obrimCodecDecodeBase10(string(data))
case obrimCodecFormatBase16:
value, err = obrimCodecDecodeBase16(string(data))
case obrimCodecFormatBase32:
value, err = obrimCodecDecodeBase32(string(data))
case obrimCodecFormatBase64:
value, err = obrimCodecDecodeBase64(string(data))
case obrimCodecFormatSqids:
value, err = obrimCodecDecodeSqids(string(data), config)
default:
return "", obrimCodecFailureInvalidFormat
}
if err != nil {
if config.format == obrimCodecFormatSqids {
return "", obrimCodecFailureSqids
}
return "", obrimCodecFailureDecoding
}
value, err = obrimCodecApplyDecodeTransformations(value, config)
if err != nil {
return "", obrimCodecFailureTransformationReversal
}
return string(value), ""
}
func obrimCodecEncodeBase8(data []byte) (string, error) {
if len(data) == 0 {
return "", fmt.Errorf("empty data")
}
number := new(big.Int).SetBytes(data)
return number.Text(8), nil
}
func obrimCodecEncodeBase10(data []byte) (string, error) {
if len(data) == 0 {
return "", fmt.Errorf("empty data")
}
number := new(big.Int).SetBytes(data)
return number.Text(10), nil
}
func obrimCodecEncodeBase16(data []byte) (string, error) {
if len(data) == 0 {
return "", fmt.Errorf("empty data")
}
return hex.EncodeToString(data), nil
}
func obrimCodecEncodeBase32(data []byte) (string, error) {
if len(data) == 0 {
return "", fmt.Errorf("empty data")
}
return base32.StdEncoding.WithPadding(base32.NoPadding).EncodeToString(data), nil
}
func obrimCodecEncodeBase64(data []byte) (string, error) {
if len(data) == 0 {
return "", fmt.Errorf("empty data")
}
return base64.StdEncoding.EncodeToString(data), nil
}
func obrimCodecEncodeSqids(data []byte, config obrimCodecConfig) (string, error) {
if len(data) == 0 {
return "", fmt.Errorf("empty data")
}
number := new(big.Int).SetBytes(data)
if !number.IsUint64() {
return "", fmt.Errorf("sqids input exceeds uint64")
}
options := sqids.Options{}
if config.charset != "" {
options.Alphabet = config.charset
}
if config.length > 0 {
options.MinLength = config.length
}
encoder, err := sqids.New(options)
if err != nil {
return "", err
}
return encoder.Encode([]uint64{number.Uint64()}), nil
}
func obrimCodecDecodeBase8(data string) ([]byte, error) {
data = strings.TrimSpace(data)
if data == "" {
return nil, fmt.Errorf("empty data")
}
number := new(big.Int)
if _, ok := number.SetString(data, 8); !ok {
return nil, fmt.Errorf("invalid base8 value")
}
return obrimCodecBigIntBytes(number), nil
}
func obrimCodecDecodeBase10(data string) ([]byte, error) {
data = strings.TrimSpace(data)
if data == "" {
return nil, fmt.Errorf("empty data")
}
number := new(big.Int)
if _, ok := number.SetString(data, 10); !ok {
return nil, fmt.Errorf("invalid base10 value")
}
return obrimCodecBigIntBytes(number), nil
}
func obrimCodecDecodeBase16(data string) ([]byte, error) {
data = strings.TrimSpace(data)
if data == "" {
return nil, fmt.Errorf("empty data")
}
if len(data)%2 != 0 {
data = "0" + data
}
return hex.DecodeString(data)
}
func obrimCodecDecodeBase32(data string) ([]byte, error) {
data = strings.TrimSpace(data)
if data == "" {
return nil, fmt.Errorf("empty data")
}
padding := len(data) % 8
if padding != 0 {
data += strings.Repeat("=", 8-padding)
}
return base32.StdEncoding.DecodeString(data)
}
func obrimCodecDecodeBase64(data string) ([]byte, error) {
data = strings.TrimSpace(data)
if data == "" {
return nil, fmt.Errorf("empty data")
}
return base64.StdEncoding.DecodeString(data)
}
func obrimCodecDecodeSqids(data string, config obrimCodecConfig) ([]byte, error) {
if data == "" {
return nil, fmt.Errorf("empty data")
}
options := sqids.Options{}
if config.charset != "" {
options.Alphabet = config.charset
}
if config.length > 0 {
options.MinLength = config.length
}
encoder, err := sqids.New(options)
if err != nil {
return nil, err
}
numbers := encoder.Decode(data)
if len(numbers) != 1 {
return nil, fmt.Errorf("invalid sqids value")
}
number := new(big.Int).SetUint64(numbers[0])
return obrimCodecBigIntBytes(number), nil
}
func obrimCodecBigIntBytes(number *big.Int) []byte {
if number.Sign() == 0 {
return []byte{0}
}
return number.Bytes()
}
func obrimCodecApplyEncodeTransformations(data []byte, config obrimCodecConfig) ([]byte, string) {
result := append([]byte(nil), data...)
if config.salt != "" {
result = obrimCodecApplySalt(result, []byte(config.salt))
}
if config.charset != "" && config.format != obrimCodecFormatSqids {
transformed, err := obrimCodecApplyCharsetEncode(result, config.charset)
if err != nil {
return nil, obrimCodecFailureTransformation
}
result = transformed
}
return result, ""
}
func obrimCodecApplyDecodeTransformations(data []byte, config obrimCodecConfig) ([]byte, error) {
result := append([]byte(nil), data...)
if config.charset != "" && config.format != obrimCodecFormatSqids {
transformed, err := obrimCodecApplyCharsetDecode(result, config.charset)
if err != nil {
return nil, err
}
result = transformed
}
if config.salt != "" {
result = obrimCodecApplySalt(result, []byte(config.salt))
}
return result, nil
}
func obrimCodecApplyCharsetEncode(data []byte, charset string) ([]byte, error) {
charsetBytes := []byte(charset)
if len(charsetBytes) < 2 {
return nil, fmt.Errorf("charset must contain at least two characters")
}
result := make([]byte, len(data))
for index, value := range data {
result[index] = charsetBytes[int(value)%len(charsetBytes)]
}
return result, nil
}
func obrimCodecApplyCharsetDecode(data []byte, charset string) ([]byte, error) {
charsetBytes := []byte(charset)
if len(charsetBytes) < 2 {
return nil, fmt.Errorf("charset must contain at least two characters")
}
reverse := make(map[byte]byte, len(charsetBytes))
for index, value := range charsetBytes {
if _, exists := reverse[value]; exists {
return nil, fmt.Errorf("charset contains duplicate characters")
}
reverse[value] = byte(index)
}
result := make([]byte, len(data))
for index, value := range data {
decoded, exists := reverse[value]
if !exists {
return nil, fmt.Errorf("character not present in charset")
}
result[index] = decoded
}
return result, nil
}
func obrimCodecApplySalt(data []byte, salt []byte) []byte {
if len(salt) == 0 {
return data
}
result := make([]byte, len(data))
for index, value := range data {
result[index] = value ^ salt[index%len(salt)]
}
return result
}
func obrimCodecApplyCase(value string, caseRule string) string {
switch caseRule {
case obrimCodecCaseLower:
return strings.ToLower(value)
case obrimCodecCaseUpper:
return strings.ToUpper(value)
default:
return value
}
}
var _ = bytes.Compare
var _ = json.Valid

344
essential/visible/service/helper/datetime/datetime.go
View File

@ -1,344 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Datetime
|
| Purpose:
| - Retrieve the current date and time from the host system clock or
| trusted clock state and return the formatted result using a supported
| framework date/time pattern.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use local to retrieve the current date and time while preserving the
| host system timezone.
| - Use cloud to retrieve the current trusted UTC date and time using the
| resolved clock state.
| - Provide the format configuration when a specific supported date/time
| representation is required.
| - Use the utility through ObrimDatetime(type string, config map[string]any).
|
| Example:
| - ObrimDatetime("local", map[string]any{
| "format": "yyyy-MM-dd",
| })
|
| - ObrimDatetime("local", map[string]any{
| "format": "HH:mm:ss",
| })
|
| - ObrimDatetime("cloud", map[string]any{
| "format": "yyyy-MM-dd HH:mm:ss z",
| })
|
| - ObrimDatetime("cloud", map[string]any{
| "format": "yyyy-MM-dd'T'HH:mm:ssXXX",
| })
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package datetime
import (
"time"
"go/module/essential/hidden/service/worker/clock"
)
// Reusable datetime input and result constants.
const (
obrimDatetimeTypeLocal = "local"
obrimDatetimeTypeCloud = "cloud"
obrimDatetimeFormatTimestampSec = "timestampsec"
obrimDatetimeFormatTimestampMil = "timestampmil"
obrimDatetimeFormatYearMonthDay = "yyyy-MM-dd"
obrimDatetimeFormatMonthDayYear = "MMM dd, yyyy"
obrimDatetimeFormatFullMonthDayYear = "MMMM dd, yyyy"
obrimDatetimeFormatWeekdayMonthDayYear = "EEE, MMM dd, yyyy"
obrimDatetimeFormatWeekdayFullMonthDayYear = "EEE, MMMM dd, yyyy"
obrimDatetimeFormatFullWeekdayMonthDayYear = "EEEE, MMM dd, yyyy"
obrimDatetimeFormatFullWeekdayFullMonthDayYear = "EEEE, MMMM dd, yyyy"
obrimDatetimeFormatTime = "HH:mm:ss"
obrimDatetimeFormatTime12 = "hh:mm:ss a"
obrimDatetimeFormatDateTime = "yyyy-MM-dd HH:mm:ss"
obrimDatetimeFormatDateTimeZone = "yyyy-MM-dd HH:mm:ss z"
obrimDatetimeFormatISO8601 = "yyyy-MM-dd'T'HH:mm:ssXXX"
obrimDatetimeSuccessRetrieved = "SUCCESS_DATETIME_RETRIEVED"
obrimDatetimeFailureInvalidType = "FAILURE_INVALID_TYPE"
obrimDatetimeFailureInvalidFormat = "FAILURE_INVALID_FORMAT"
obrimDatetimeFailureTrustedTimeSource = "FAILURE_TRUSTED_TIME_SOURCE_ERROR"
)
// Datetime clock state contains the resolved synchronization information.
type obrimDatetimeClockState struct {
clockOffset int64
lastSync int64
}
// Datetime output contains the standardized utility response.
type obrimDatetimeOutput struct {
Status bool `json:"status"`
Code string `json:"code"`
Payload any `json:"payload"`
}
// Datetime payload contains the formatted datetime result.
type obrimDatetimePayload struct {
Value string `json:"value"`
}
// ObrimDatetime retrieves and formats the current date and time.
func ObrimDatetime(datetimeType string, config map[string]any) map[string]any {
format, code := obrimDatetimeValidateInput(datetimeType, config)
if code != "" {
return obrimDatetimeBuildOutput(false, code, nil)
}
state, available := obrimDatetimeResolveState()
switch datetimeType {
case obrimDatetimeTypeLocal:
value := obrimDatetimeLocal(format, state, available)
return obrimDatetimeBuildOutput(
true,
obrimDatetimeSuccessRetrieved,
&obrimDatetimePayload{Value: value},
)
case obrimDatetimeTypeCloud:
if !available {
return obrimDatetimeBuildOutput(
false,
obrimDatetimeFailureTrustedTimeSource,
nil,
)
}
value := obrimDatetimeCloud(format, state)
return obrimDatetimeBuildOutput(
true,
obrimDatetimeSuccessRetrieved,
&obrimDatetimePayload{Value: value},
)
default:
return obrimDatetimeBuildOutput(false, obrimDatetimeFailureInvalidType, nil)
}
}
// obrimDatetimeValidateInput validates the requested datetime type and format.
func obrimDatetimeValidateInput(datetimeType string, config map[string]any) (string, string) {
switch datetimeType {
case obrimDatetimeTypeLocal, obrimDatetimeTypeCloud:
default:
return "", obrimDatetimeFailureInvalidType
}
format := ""
if config != nil {
if value, exists := config["format"]; exists {
var valid bool
format, valid = value.(string)
if !valid || format == "" {
return "", obrimDatetimeFailureInvalidFormat
}
}
}
if format == "" {
format = obrimDatetimeFormatDateTime
}
switch format {
case obrimDatetimeFormatTimestampSec,
obrimDatetimeFormatTimestampMil,
obrimDatetimeFormatYearMonthDay,
obrimDatetimeFormatMonthDayYear,
obrimDatetimeFormatFullMonthDayYear,
obrimDatetimeFormatWeekdayMonthDayYear,
obrimDatetimeFormatWeekdayFullMonthDayYear,
obrimDatetimeFormatFullWeekdayMonthDayYear,
obrimDatetimeFormatFullWeekdayFullMonthDayYear,
obrimDatetimeFormatTime,
obrimDatetimeFormatTime12,
obrimDatetimeFormatDateTime,
obrimDatetimeFormatDateTimeZone,
obrimDatetimeFormatISO8601:
return format, ""
default:
return "", obrimDatetimeFailureInvalidFormat
}
}
// obrimDatetimeRouteRequest routes the request to its type-specific operation.
func obrimDatetimeRouteRequest(
datetimeType string,
format string,
state obrimDatetimeClockState,
available bool,
) (string, string) {
switch datetimeType {
case obrimDatetimeTypeLocal:
return obrimDatetimeLocal(format, state, available), ""
case obrimDatetimeTypeCloud:
if !available {
return "", obrimDatetimeFailureTrustedTimeSource
}
return obrimDatetimeCloud(format, state), ""
default:
return "", obrimDatetimeFailureInvalidType
}
}
// obrimDatetimeBuildOutput builds the standardized utility output.
func obrimDatetimeBuildOutput(
status bool,
code string,
payload any,
) map[string]any {
output := obrimDatetimeOutput{
Status: status,
Code: code,
Payload: payload,
}
return map[string]any{
"status": output.Status,
"code": output.Code,
"payload": output.Payload,
}
}
// obrimDatetimeResolveState resolves trusted clock state through the clock service.
func obrimDatetimeResolveState() (obrimDatetimeClockState, bool) {
now := time.Now()
trusted := clock.ObrimClockCurrentClock()
offset := trusted.Sub(now.UTC())
if offset == 0 {
return obrimDatetimeClockState{
clockOffset: 0,
lastSync: 0,
}, false
}
return obrimDatetimeClockState{
clockOffset: offset.Nanoseconds(),
lastSync: trusted.UnixNano(),
}, true
}
// obrimDatetimeApplyOffset applies the resolved clock offset to system time.
func obrimDatetimeApplyOffset(value time.Time, state obrimDatetimeClockState) time.Time {
return value.Add(time.Duration(state.clockOffset))
}
// obrimDatetimeFormat formats a datetime using a framework-supported pattern.
func obrimDatetimeFormat(value time.Time, format string) string {
switch format {
case obrimDatetimeFormatTimestampSec:
return formatTimestampSeconds(value)
case obrimDatetimeFormatTimestampMil:
return formatTimestampMilliseconds(value)
case obrimDatetimeFormatYearMonthDay:
return value.Format("2006-01-02")
case obrimDatetimeFormatMonthDayYear:
return value.Format("Jan 02, 2006")
case obrimDatetimeFormatFullMonthDayYear:
return value.Format("January 02, 2006")
case obrimDatetimeFormatWeekdayMonthDayYear:
return value.Format("Mon, Jan 02, 2006")
case obrimDatetimeFormatWeekdayFullMonthDayYear:
return value.Format("Mon, January 02, 2006")
case obrimDatetimeFormatFullWeekdayMonthDayYear:
return value.Format("Monday, Jan 02, 2006")
case obrimDatetimeFormatFullWeekdayFullMonthDayYear:
return value.Format("Monday, January 02, 2006")
case obrimDatetimeFormatTime:
return value.Format("15:04:05")
case obrimDatetimeFormatTime12:
return value.Format("03:04:05 PM")
case obrimDatetimeFormatDateTime:
return value.Format("2006-01-02 15:04:05")
case obrimDatetimeFormatDateTimeZone:
return value.Format("2006-01-02 15:04:05 MST")
case obrimDatetimeFormatISO8601:
return value.Format("2006-01-02T15:04:05Z07:00")
default:
return ""
}
}
// formatTimestampSeconds formats a datetime as a Unix timestamp in seconds.
func formatTimestampSeconds(value time.Time) string {
return value.Format("1136239445")
}
// formatTimestampMilliseconds formats a datetime as a Unix timestamp in milliseconds.
func formatTimestampMilliseconds(value time.Time) string {
return value.Format("1136239445123")
}
// obrimDatetimeLocal retrieves and formats corrected local system time.
func obrimDatetimeLocal(
format string,
state obrimDatetimeClockState,
available bool,
) string {
value := time.Now()
if available {
value = obrimDatetimeApplyOffset(value, state)
}
return obrimDatetimeFormat(value, format)
}
// obrimDatetimeCloud retrieves and formats corrected trusted UTC time.
func obrimDatetimeCloud(
format string,
state obrimDatetimeClockState,
) string {
value := obrimDatetimeApplyOffset(time.Now().UTC(), state).UTC()
return obrimDatetimeFormat(value, format)
}

1212
essential/visible/service/helper/filesystem/filesystem.go
View File

File diff suppressed because it is too large Load Diff

396
essential/visible/service/helper/hash/hash.go
View File

@ -1,396 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Hash
|
| Purpose:
| - Generate and verify cryptographic hash values using standard or
| salted hashing methods for integrity verification, canonical
| fingerprinting, resource identification, comparison workflows,
| and security-oriented hashing requirements.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use to generate deterministic hashes in standard mode.
| - Use to generate salted hashes when salted hashing is required.
| - Use to verify supplied hash values against input values.
| - Use standard mode when deterministic hashing without a salt is
| required.
| - Use salted mode when a supplied or cryptographically secure
| generated salt is required.
|
| Example:
| - ObrimHash("calculate", map[string]any{
| "mode": "standard",
| "algorithm": "...",
| "value": "...",
| })
|
| - ObrimHash("calculate", map[string]any{
| "mode": "salted",
| "algorithm": "...",
| "value": "...",
| "salt": "...",
| })
|
| - ObrimHash("compare", map[string]any{
| "mode": "standard",
| "algorithm": "...",
| "value": "...",
| "hash": "...",
| })
|
| - ObrimHash("compare", map[string]any{
| "mode": "salted",
| "algorithm": "...",
| "value": "...",
| "hash": "...",
| "salt": "...",
| })
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package hash
import (
"crypto/rand"
"crypto/sha256"
"crypto/sha512"
"encoding/hex"
"errors"
"hash"
)
// Hash result codes.
const (
ObrimHashSuccessCalculated = "SUCCESS_CALCULATED"
ObrimHashSuccessCompared = "SUCCESS_COMPARED"
ObrimHashFailureInvalidType = "FAILURE_INVALID_TYPE"
ObrimHashFailureInvalidConfig = "FAILURE_INVALID_CONFIG"
ObrimHashFailureInvalidMode = "FAILURE_INVALID_MODE"
ObrimHashFailureInvalidAlgorithm = "FAILURE_INVALID_ALGORITHM"
ObrimHashFailureInvalidValue = "FAILURE_INVALID_VALUE"
ObrimHashFailureInvalidHash = "FAILURE_INVALID_HASH"
ObrimHashFailureInvalidSalt = "FAILURE_INVALID_SALT"
ObrimHashFailureProcessing = "FAILURE_PROCESSING"
)
// Hash utility modes.
const (
obrimHashModeStandard = "standard"
obrimHashModeSalted = "salted"
)
// Hash utility algorithms.
const (
obrimHashAlgorithmSHA256 = "sha256"
obrimHashAlgorithmSHA512 = "sha512"
)
// Hash utility configuration keys.
const (
obrimHashConfigMode = "mode"
obrimHashConfigAlgorithm = "algorithm"
obrimHashConfigValue = "value"
obrimHashConfigHash = "hash"
obrimHashConfigSalt = "salt"
)
// Hash utility operation types.
const (
obrimHashTypeCalculate = "calculate"
obrimHashTypeCompare = "compare"
)
// Hash utility output structure.
type obrimHashOutput struct {
Status bool `json:"status"`
Code string `json:"code"`
Payload map[string]any `json:"payload"`
}
// Hash utility request configuration.
type obrimHashConfig struct {
Mode string
Algorithm string
Value string
Hash string
Salt string
}
// Hash utility execution function.
func ObrimHash(Type string, Config map[string]any) map[string]any {
ConfigData, Code := obrimHashValidateInput(Type, Config)
if Code != "" {
return obrimHashBuildOutput(false, Code, nil)
}
return obrimHashRouteRequest(Type, ConfigData)
}
// Validate hash utility input.
func obrimHashValidateInput(Type string, Config map[string]any) (obrimHashConfig, string) {
var ConfigData obrimHashConfig
switch Type {
case obrimHashTypeCalculate, obrimHashTypeCompare:
default:
return ConfigData, ObrimHashFailureInvalidType
}
if Config == nil {
return ConfigData, ObrimHashFailureInvalidConfig
}
ConfigData.Mode = obrimHashReadStringConfig(Config, obrimHashConfigMode)
ConfigData.Algorithm = obrimHashReadStringConfig(Config, obrimHashConfigAlgorithm)
ConfigData.Value = obrimHashReadStringConfig(Config, obrimHashConfigValue)
ConfigData.Hash = obrimHashReadStringConfig(Config, obrimHashConfigHash)
ConfigData.Salt = obrimHashReadStringConfig(Config, obrimHashConfigSalt)
switch ConfigData.Mode {
case obrimHashModeStandard, obrimHashModeSalted:
default:
return ConfigData, ObrimHashFailureInvalidMode
}
switch ConfigData.Algorithm {
case obrimHashAlgorithmSHA256, obrimHashAlgorithmSHA512:
default:
return ConfigData, ObrimHashFailureInvalidAlgorithm
}
if ConfigData.Value == "" {
return ConfigData, ObrimHashFailureInvalidValue
}
switch Type {
case obrimHashTypeCalculate:
if ConfigData.Mode == obrimHashModeStandard && ConfigData.Salt != "" {
return ConfigData, ObrimHashFailureInvalidSalt
}
case obrimHashTypeCompare:
if ConfigData.Hash == "" {
return ConfigData, ObrimHashFailureInvalidHash
}
switch ConfigData.Mode {
case obrimHashModeStandard:
if ConfigData.Salt != "" {
return ConfigData, ObrimHashFailureInvalidSalt
}
case obrimHashModeSalted:
if ConfigData.Salt == "" {
return ConfigData, ObrimHashFailureInvalidSalt
}
}
}
return ConfigData, ""
}
// Route the hash utility request.
func obrimHashRouteRequest(Type string, Config obrimHashConfig) map[string]any {
switch Type {
case obrimHashTypeCalculate:
return obrimHashCalculate(Config)
case obrimHashTypeCompare:
return obrimHashCompare(Config)
default:
return obrimHashBuildOutput(false, ObrimHashFailureInvalidType, nil)
}
}
// Build standardized hash utility output.
func obrimHashBuildOutput(Status bool, Code string, Payload map[string]any) map[string]any {
Output := obrimHashOutput{
Status: Status,
Code: Code,
Payload: Payload,
}
return map[string]any{
"status": Output.Status,
"code": Output.Code,
"payload": Output.Payload,
}
}
// Process hash generation.
func obrimHashCalculate(Config obrimHashConfig) map[string]any {
switch Config.Mode {
case obrimHashModeStandard:
return obrimHashCalculateStandard(Config)
case obrimHashModeSalted:
return obrimHashCalculateSalted(Config)
default:
return obrimHashBuildOutput(false, ObrimHashFailureInvalidMode, nil)
}
}
// Generate deterministic standard hash.
func obrimHashCalculateStandard(Config obrimHashConfig) map[string]any {
HashValue, Error := obrimHashGenerate(Config.Algorithm, Config.Value)
if Error != nil {
return obrimHashBuildOutput(false, ObrimHashFailureProcessing, nil)
}
Payload := map[string]any{
"algorithm": Config.Algorithm,
"hash": HashValue,
}
return obrimHashBuildOutput(true, ObrimHashSuccessCalculated, Payload)
}
// Generate salted hash.
func obrimHashCalculateSalted(Config obrimHashConfig) map[string]any {
Salt := Config.Salt
if Salt == "" {
var Error error
Salt, Error = obrimHashGenerateSalt()
if Error != nil {
return obrimHashBuildOutput(false, ObrimHashFailureProcessing, nil)
}
}
HashValue, Error := obrimHashGenerate(Config.Algorithm, Salt+Config.Value)
if Error != nil {
return obrimHashBuildOutput(false, ObrimHashFailureProcessing, nil)
}
Payload := map[string]any{
"algorithm": Config.Algorithm,
"hash": HashValue,
"salt": Salt,
}
return obrimHashBuildOutput(true, ObrimHashSuccessCalculated, Payload)
}
// Generate a cryptographically secure random salt.
func obrimHashGenerateSalt() (string, error) {
Salt := make([]byte, 32)
if _, Error := rand.Read(Salt); Error != nil {
return "", Error
}
return hex.EncodeToString(Salt), nil
}
// Process hash verification.
func obrimHashCompare(Config obrimHashConfig) map[string]any {
switch Config.Mode {
case obrimHashModeStandard:
return obrimHashCompareStandard(Config)
case obrimHashModeSalted:
return obrimHashCompareSalted(Config)
default:
return obrimHashBuildOutput(false, ObrimHashFailureInvalidMode, nil)
}
}
// Verify standard hash.
func obrimHashCompareStandard(Config obrimHashConfig) map[string]any {
HashValue, Error := obrimHashGenerate(Config.Algorithm, Config.Value)
if Error != nil {
return obrimHashBuildOutput(false, ObrimHashFailureProcessing, nil)
}
Matched := obrimHashVerify(HashValue, Config.Hash)
Payload := map[string]any{
"algorithm": Config.Algorithm,
"matched": Matched,
"hash": Config.Hash,
}
return obrimHashBuildOutput(true, ObrimHashSuccessCompared, Payload)
}
// Verify salted hash.
func obrimHashCompareSalted(Config obrimHashConfig) map[string]any {
HashValue, Error := obrimHashGenerate(Config.Algorithm, Config.Salt+Config.Value)
if Error != nil {
return obrimHashBuildOutput(false, ObrimHashFailureProcessing, nil)
}
Matched := obrimHashVerify(HashValue, Config.Hash)
Payload := map[string]any{
"algorithm": Config.Algorithm,
"matched": Matched,
"hash": Config.Hash,
"salt": Config.Salt,
}
return obrimHashBuildOutput(true, ObrimHashSuccessCompared, Payload)
}
// Verify regenerated and supplied hashes using strict byte comparison.
func obrimHashVerify(Expected string, Supplied string) bool {
return string([]byte(Expected)) == string([]byte(Supplied))
}
// Generate a hash using the selected algorithm.
func obrimHashGenerate(Algorithm string, Value string) (string, error) {
var HashFunction func() hash.Hash
switch Algorithm {
case obrimHashAlgorithmSHA256:
HashFunction = sha256.New
case obrimHashAlgorithmSHA512:
HashFunction = sha512.New
default:
return "", errors.New("unsupported hashing algorithm")
}
Hasher := HashFunction()
if _, Error := Hasher.Write([]byte(Value)); Error != nil {
return "", Error
}
return hex.EncodeToString(Hasher.Sum(nil)), nil
}
// Read a string configuration value.
func obrimHashReadStringConfig(Config map[string]any, Key string) string {
Value, Exists := Config[Key]
if !Exists || Value == nil {
return ""
}
StringValue, Valid := Value.(string)
if !Valid {
return ""
}
return StringValue
}

445
essential/visible/service/helper/key/key.go
View File

@ -1,445 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Key
|
| Purpose:
| - Generate cryptographic key material through a type-driven dispatch
| model supporting symmetric and asymmetric key generation.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use the utility to generate cryptographically secure symmetric or
| asymmetric key material.
| - Use the "symmetric" type with the supported AES algorithm and
| 128, 192, or 256 bit key sizes.
| - Use the "asymmetric" type with the supported ECC algorithm using
| the EdDSA curve.
| - Provide the type-specific configuration required for the selected
| key generation workflow.
|
| Example:
| - ObrimKey("symmetric", map[string]any{
| "algorithm": "aes",
| "key_size": 256,
| })
|
| - ObrimKey("asymmetric", map[string]any{
| "algorithm": "ecc",
| })
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package key
import (
"crypto/aes"
"crypto/ed25519"
"crypto/rand"
"encoding/base64"
"time"
)
const (
obrimKeyTypeSymmetric = "symmetric"
obrimKeyTypeAsymmetric = "asymmetric"
obrimKeyAlgorithmAES = "aes"
obrimKeyAlgorithmECC = "ecc"
obrimKeyCurveEdDSA = "eddsa"
obrimKeySize128 = 128
obrimKeySize192 = 192
obrimKeySize256 = 256
)
const (
obrimKeySuccessSymmetricGenerated = "SUCCESS_SYMMETRIC_KEY_GENERATED"
obrimKeySuccessAsymmetricGenerated = "SUCCESS_ASYMMETRIC_KEY_GENERATED"
obrimKeyFailureInvalidType = "FAILURE_INVALID_TYPE"
obrimKeyFailureInvalidConfig = "FAILURE_INVALID_CONFIG"
obrimKeyFailureMissingAlgorithm = "FAILURE_MISSING_ALGORITHM"
obrimKeyFailureInvalidAlgorithm = "FAILURE_INVALID_ALGORITHM"
obrimKeyFailureMissingKeySize = "FAILURE_MISSING_KEY_SIZE"
obrimKeyFailureInvalidKeySize = "FAILURE_INVALID_KEY_SIZE"
obrimKeyFailureKeyGeneration = "FAILURE_KEY_GENERATION"
obrimKeyFailureAsymmetricKeyGeneration = "FAILURE_ASYMMETRIC_KEY_GENERATION"
obrimKeyFailureUnsupportedOperation = "FAILURE_UNSUPPORTED_OPERATION"
)
const (
obrimKeyConfigAlgorithm = "algorithm"
obrimKeyConfigKeySize = "key_size"
)
type obrimKeySymmetricConfig struct {
algorithm string
keySize int
}
type obrimKeyAsymmetricConfig struct {
algorithm string
}
type obrimKeySymmetricPayload struct {
Type string `json:"type"`
Algorithm string `json:"algorithm"`
KeySize int `json:"key_size"`
KeyMaterial string `json:"key_material"`
GeneratedAt string `json:"generated_at"`
}
type obrimKeyAsymmetricPayload struct {
Type string `json:"type"`
Algorithm string `json:"algorithm"`
Curve string `json:"curve"`
PublicKey string `json:"public_key"`
PrivateKey string `json:"private_key"`
GeneratedAt string `json:"generated_at"`
}
type obrimKeyOutput struct {
Status bool `json:"status"`
Code string `json:"code"`
Payload any `json:"payload"`
}
func ObrimKey(keyType string, config map[string]any) map[string]any {
if code := obrimKeyValidateInput(keyType, config); code != "" {
return obrimKeyBuildOutput(false, code, nil)
}
return obrimKeyRouteRequest(keyType, config)
}
func obrimKeyValidateInput(keyType string, config map[string]any) string {
switch keyType {
case obrimKeyTypeSymmetric:
if config == nil {
return obrimKeyFailureInvalidConfig
}
algorithm, ok := config[obrimKeyConfigAlgorithm]
if !ok {
return obrimKeyFailureMissingAlgorithm
}
algorithmValue, ok := algorithm.(string)
if !ok || algorithmValue == "" {
return obrimKeyFailureInvalidAlgorithm
}
switch algorithmValue {
case obrimKeyAlgorithmAES:
default:
return obrimKeyFailureInvalidAlgorithm
}
keySize, ok := config[obrimKeyConfigKeySize]
if !ok {
return obrimKeyFailureMissingKeySize
}
switch value := keySize.(type) {
case int:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case int8:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case int16:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case int32:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case int64:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case uint:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case uint8:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case uint16:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case uint32:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
case uint64:
switch value {
case obrimKeySize128, obrimKeySize192, obrimKeySize256:
default:
return obrimKeyFailureInvalidKeySize
}
default:
return obrimKeyFailureInvalidKeySize
}
case obrimKeyTypeAsymmetric:
if config == nil {
return obrimKeyFailureInvalidConfig
}
algorithm, ok := config[obrimKeyConfigAlgorithm]
if !ok {
return obrimKeyFailureMissingAlgorithm
}
algorithmValue, ok := algorithm.(string)
if !ok || algorithmValue == "" {
return obrimKeyFailureInvalidAlgorithm
}
switch algorithmValue {
case obrimKeyAlgorithmECC:
default:
return obrimKeyFailureInvalidAlgorithm
}
default:
return obrimKeyFailureInvalidType
}
return ""
}
func obrimKeyRouteRequest(keyType string, config map[string]any) map[string]any {
switch keyType {
case obrimKeyTypeSymmetric:
normalized, code := obrimKeyNormalizeSymmetricConfig(config)
if code != "" {
return obrimKeyBuildOutput(false, code, nil)
}
payload, code := obrimKeyGenerateSymmetric(normalized)
if code != "" {
return obrimKeyBuildOutput(false, code, nil)
}
return obrimKeyBuildOutput(
true,
obrimKeySuccessSymmetricGenerated,
payload,
)
case obrimKeyTypeAsymmetric:
normalized, code := obrimKeyNormalizeAsymmetricConfig(config)
if code != "" {
return obrimKeyBuildOutput(false, code, nil)
}
payload, code := obrimKeyGenerateAsymmetric(normalized)
if code != "" {
return obrimKeyBuildOutput(false, code, nil)
}
return obrimKeyBuildOutput(
true,
obrimKeySuccessAsymmetricGenerated,
payload,
)
default:
return obrimKeyBuildOutput(false, obrimKeyFailureUnsupportedOperation, nil)
}
}
func obrimKeyBuildOutput(status bool, code string, payload any) map[string]any {
output := obrimKeyOutput{
Status: status,
Code: code,
Payload: payload,
}
return map[string]any{
"status": output.Status,
"code": output.Code,
"payload": output.Payload,
}
}
func obrimKeyNormalizeSymmetricConfig(config map[string]any) (obrimKeySymmetricConfig, string) {
algorithm, ok := config[obrimKeyConfigAlgorithm].(string)
if !ok || algorithm == "" {
return obrimKeySymmetricConfig{}, obrimKeyFailureInvalidAlgorithm
}
keySizeValue, ok := config[obrimKeyConfigKeySize]
if !ok {
return obrimKeySymmetricConfig{}, obrimKeyFailureMissingKeySize
}
keySize, ok := obrimKeyNormalizeKeySize(keySizeValue)
if !ok {
return obrimKeySymmetricConfig{}, obrimKeyFailureInvalidKeySize
}
return obrimKeySymmetricConfig{
algorithm: algorithm,
keySize: keySize,
}, ""
}
func obrimKeyNormalizeKeySize(value any) (int, bool) {
switch keySize := value.(type) {
case int:
return keySize, true
case int8:
return int(keySize), true
case int16:
return int(keySize), true
case int32:
return int(keySize), true
case int64:
return int(keySize), true
case uint:
return int(keySize), true
case uint8:
return int(keySize), true
case uint16:
return int(keySize), true
case uint32:
return int(keySize), true
case uint64:
return int(keySize), true
default:
return 0, false
}
}
func obrimKeyGenerateSymmetric(config obrimKeySymmetricConfig) (map[string]any, string) {
switch config.algorithm {
case obrimKeyAlgorithmAES:
return obrimKeyGenerateAES(config.keySize)
default:
return nil, obrimKeyFailureInvalidAlgorithm
}
}
func obrimKeyGenerateAES(keySize int) (map[string]any, string) {
keyLength := keySize / 8
keyMaterial := make([]byte, keyLength)
if _, err := rand.Read(keyMaterial); err != nil {
return nil, obrimKeyFailureKeyGeneration
}
if _, err := aes.NewCipher(keyMaterial); err != nil {
return nil, obrimKeyFailureKeyGeneration
}
payload := obrimKeySymmetricPayload{
Type: obrimKeyTypeSymmetric,
Algorithm: obrimKeyAlgorithmAES,
KeySize: keySize,
KeyMaterial: base64.StdEncoding.EncodeToString(keyMaterial),
GeneratedAt: time.Now().UTC().Format(time.RFC3339Nano),
}
return map[string]any{
"type": payload.Type,
"algorithm": payload.Algorithm,
"key_size": payload.KeySize,
"key_material": payload.KeyMaterial,
"generated_at": payload.GeneratedAt,
}, ""
}
func obrimKeyNormalizeAsymmetricConfig(config map[string]any) (obrimKeyAsymmetricConfig, string) {
algorithm, ok := config[obrimKeyConfigAlgorithm].(string)
if !ok || algorithm == "" {
return obrimKeyAsymmetricConfig{}, obrimKeyFailureInvalidAlgorithm
}
return obrimKeyAsymmetricConfig{
algorithm: algorithm,
}, ""
}
func obrimKeyGenerateAsymmetric(config obrimKeyAsymmetricConfig) (map[string]any, string) {
switch config.algorithm {
case obrimKeyAlgorithmECC:
return obrimKeyGenerateECC()
default:
return nil, obrimKeyFailureInvalidAlgorithm
}
}
func obrimKeyGenerateECC() (map[string]any, string) {
publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
if err != nil {
return nil, obrimKeyFailureAsymmetricKeyGeneration
}
payload := obrimKeyAsymmetricPayload{
Type: obrimKeyTypeAsymmetric,
Algorithm: obrimKeyAlgorithmECC,
Curve: obrimKeyCurveEdDSA,
PublicKey: base64.StdEncoding.EncodeToString(publicKey),
PrivateKey: base64.StdEncoding.EncodeToString(privateKey),
GeneratedAt: time.Now().UTC().Format(time.RFC3339Nano),
}
return map[string]any{
"type": payload.Type,
"algorithm": payload.Algorithm,
"curve": payload.Curve,
"public_key": payload.PublicKey,
"private_key": payload.PrivateKey,
"generated_at": payload.GeneratedAt,
}, ""
}

225
essential/visible/service/helper/log/log.go
View File

@ -1,225 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Log
|
| Purpose:
| - Provide a framework-level logging utility that records structured
| plaintext log entries to a persistent filesystem location using a
| deterministic and platform-aware storage strategy.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use to write standardized log messages from framework services and
| software features.
| - Provide a logical source identifier using the SERVICENAME/UTILITYNAME
| or SERVICENAME/FEATURENAME format.
| - Provide the human-readable log message as plain, formatted, or any
| UTF-8 string.
| - Log entries are stored in the platform-specific persistent log
| directory using the software name as the directory name.
| - Log entries are appended as complete UTF-8 plaintext lines without
| overwriting existing content.
|
| Example:
| - ObrimLog(
| "SERVICENAME/UTILITYNAME",
| "Utility operation completed",
| )
| - ObrimLog(
| "SERVICENAME/FEATURENAME",
| "Feature execution started",
| )
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package log
import (
"os"
"path/filepath"
"runtime"
"strings"
"time"
)
// obrimLogSoftwareName identifies the software owning the log directory.
const obrimLogSoftwareName = "software"
// ObrimLog writes a standardized log message.
func ObrimLog(label, message string) {
obrimLogLabel, obrimLogMessage, obrimLogValid := obrimLogValidateInput(label, message)
if !obrimLogValid {
return
}
obrimLogName := obrimLogResolveName()
if obrimLogName == "" {
return
}
obrimLogDirectory, obrimLogDirectoryValid := obrimLogResolveDirectory(obrimLogName)
if !obrimLogDirectoryValid {
return
}
obrimLogFile, obrimLogFileValid := obrimLogResolveFile(obrimLogDirectory)
if !obrimLogFileValid {
return
}
obrimLogTimestamp := obrimLogGetTimestamp()
obrimLogEntry := obrimLogBuildEntry(obrimLogTimestamp, obrimLogLabel, obrimLogMessage)
obrimLogWriteEntry(obrimLogFile, obrimLogEntry)
}
// obrimLogValidateInput normalizes and validates the log input.
func obrimLogValidateInput(label, message string) (string, string, bool) {
label = strings.TrimSpace(label)
message = strings.ReplaceAll(message, "\r\n", "\n")
message = strings.ReplaceAll(message, "\r", "\n")
message = strings.ReplaceAll(message, "\n", " ")
if label == "" || message == "" {
return "", "", false
}
return label, message, true
}
// obrimLogResolveName retrieves the software name from the local constant.
func obrimLogResolveName() string {
return strings.TrimSpace(obrimLogSoftwareName)
}
// obrimLogResolveDirectory resolves and creates the platform-specific log directory.
func obrimLogResolveDirectory(softwareName string) (string, bool) {
var obrimLogDirectory string
switch runtime.GOOS {
case "linux":
obrimLogHome, obrimLogHomeError := os.UserHomeDir()
if obrimLogHomeError != nil {
return "", false
}
obrimLogDirectory = filepath.Join(
obrimLogHome,
".local",
"state",
softwareName,
"log",
"main",
)
case "windows":
obrimLogLocalAppData := strings.TrimSpace(os.Getenv("LOCALAPPDATA"))
if obrimLogLocalAppData == "" {
return "", false
}
obrimLogDirectory = filepath.Join(
obrimLogLocalAppData,
softwareName,
"log",
"main",
)
case "darwin":
obrimLogHome, obrimLogHomeError := os.UserHomeDir()
if obrimLogHomeError != nil {
return "", false
}
obrimLogDirectory = filepath.Join(
obrimLogHome,
"Library",
"Logs",
softwareName,
"log",
"main",
)
default:
return "", false
}
if obrimLogDirectory == "" {
return "", false
}
if obrimLogMkdirError := os.MkdirAll(obrimLogDirectory, 0o755); obrimLogMkdirError != nil {
return "", false
}
return obrimLogDirectory, true
}
// obrimLogResolveFile resolves and creates the main log file.
func obrimLogResolveFile(directory string) (string, bool) {
obrimLogFile := filepath.Join(directory, "main.log")
obrimLogHandle, obrimLogOpenError := os.OpenFile(
obrimLogFile,
os.O_CREATE|os.O_APPEND|os.O_WRONLY,
0o644,
)
if obrimLogOpenError != nil {
return "", false
}
if obrimLogCloseError := obrimLogHandle.Close(); obrimLogCloseError != nil {
return "", false
}
return obrimLogFile, true
}
// obrimLogGetTimestamp gets the timestamp for a log entry.
func obrimLogGetTimestamp() string {
return time.Now().Format(time.RFC3339Nano)
}
// obrimLogBuildEntry builds a complete formatted log entry.
func obrimLogBuildEntry(timestamp, label, message string) string {
return "[" + timestamp + "] [" + label + "] " + message + "\n"
}
// obrimLogWriteEntry appends a complete log entry to the log file.
func obrimLogWriteEntry(file, entry string) {
obrimLogHandle, obrimLogOpenError := os.OpenFile(
file,
os.O_APPEND|os.O_WRONLY,
0o644,
)
if obrimLogOpenError != nil {
return
}
defer obrimLogHandle.Close()
_, _ = obrimLogHandle.WriteString(entry)
}

627
essential/visible/service/helper/marker/marker.go
View File

@ -1,627 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Marker
|
| Purpose:
| - Provide a unified utility for generating unique markers through
| multiple generation strategies using a single entry point.
| - Support time-based, random, and encoded marker generation while
| maintaining a consistent output structure, deterministic routing,
| and extensible architecture.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use the time type with an epoch timestamp and instance identifier
| to generate distributed time-based markers.
| - Use the random type with a desired length and character set to
| generate collision-resistant random markers.
| - Use the encoded type with source data, output length, character
| set, and optional salt to generate deterministic encoded markers.
| - Validate the marker type and all type-specific configuration
| values before processing.
| - Use the unified ObrimMarker entry point to execute marker
| generation.
|
| Example:
| - ObrimMarker("time", map[string]any{
| "epoch": int64(0),
| "instance": "instance-01",
| })
|
| - ObrimMarker("random", map[string]any{
| "length": 32,
| "charset": "abcdefghijklmnopqrstuvwxyz0123456789",
| })
|
| - ObrimMarker("encoded", map[string]any{
| "data": "source-data",
| "length": 32,
| "charset": "abcdefghijklmnopqrstuvwxyz0123456789",
| "salt": "optional-salt",
| })
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package marker
import (
"crypto/rand"
"crypto/sha256"
"encoding/binary"
"fmt"
"strconv"
"strings"
"time"
)
const (
// Marker type identifiers.
obrimMarkerTypeTime = "time"
obrimMarkerTypeRandom = "random"
obrimMarkerTypeEncoded = "encoded"
// Default marker configuration values.
obrimMarkerDefaultEpoch int64 = 0
obrimMarkerDefaultCharset string = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
obrimMarkerDefaultLength int = 32
// Marker result codes.
obrimMarkerSuccessTime = "SUCCESS_TIME_MARKER_GENERATED"
obrimMarkerSuccessRandom = "SUCCESS_RANDOM_MARKER_GENERATED"
obrimMarkerSuccessEncoded = "SUCCESS_ENCODED_MARKER_GENERATED"
// Marker failure codes.
obrimMarkerFailureInvalidType = "FAILURE_INVALID_TYPE"
obrimMarkerFailureInvalidConfig = "FAILURE_INVALID_CONFIG"
obrimMarkerFailureInvalidEpoch = "FAILURE_INVALID_EPOCH"
obrimMarkerFailureInvalidInstance = "FAILURE_INVALID_INSTANCE"
obrimMarkerFailureInvalidLength = "FAILURE_INVALID_LENGTH"
obrimMarkerFailureInvalidCharset = "FAILURE_INVALID_CHARSET"
obrimMarkerFailureEmptySource = "FAILURE_EMPTY_SOURCE"
obrimMarkerFailureInvalidEncodingConfig = "FAILURE_INVALID_ENCODING_CONFIG"
obrimMarkerFailureGenerationError = "FAILURE_GENERATION_ERROR"
)
type obrimMarkerOutput struct {
Status bool `json:"status"`
Code string `json:"code"`
Payload any `json:"payload"`
}
type obrimMarkerTimePayload struct {
Marker string `json:"marker"`
Epoch int64 `json:"epoch"`
Instance string `json:"instance"`
}
type obrimMarkerRandomPayload struct {
Marker string `json:"marker"`
Length int `json:"length"`
Charset string `json:"charset"`
}
type obrimMarkerEncodedPayload struct {
Marker string `json:"marker"`
Source string `json:"source"`
Length int `json:"length"`
}
type obrimMarkerTimeConfig struct {
Epoch int64
Instance string
}
type obrimMarkerRandomConfig struct {
Length int
Charset string
}
type obrimMarkerEncodedConfig struct {
Data string
Length int
Charset string
Salt string
}
// ObrimMarker generates a marker using the requested generation strategy.
func ObrimMarker(typeName string, config map[string]any) map[string]any {
if code := obrimMarkerValidateInput(typeName, config); code != "" {
return obrimMarkerBuildOutput(false, code, nil)
}
payload, code := obrimMarkerRouteRequest(typeName, config)
if code != "" {
return obrimMarkerBuildOutput(false, code, nil)
}
return obrimMarkerBuildOutput(true, code, payload)
}
// obrimMarkerValidateInput validates the requested marker type and configuration.
func obrimMarkerValidateInput(typeName string, config map[string]any) string {
if config == nil {
return obrimMarkerFailureInvalidConfig
}
switch typeName {
case obrimMarkerTypeTime:
if code := obrimMarkerValidateTime(config); code != "" {
return code
}
case obrimMarkerTypeRandom:
if code := obrimMarkerValidateRandom(config); code != "" {
return code
}
case obrimMarkerTypeEncoded:
if code := obrimMarkerValidateEncoded(config); code != "" {
return code
}
default:
return obrimMarkerFailureInvalidType
}
return ""
}
// obrimMarkerRouteRequest routes the request to its type-specific workflow.
func obrimMarkerRouteRequest(typeName string, config map[string]any) (any, string) {
switch typeName {
case obrimMarkerTypeTime:
return obrimMarkerTime(config)
case obrimMarkerTypeRandom:
return obrimMarkerRandom(config)
case obrimMarkerTypeEncoded:
return obrimMarkerEncoded(config)
default:
return nil, obrimMarkerFailureInvalidType
}
}
// obrimMarkerBuildOutput builds the standardized utility output.
func obrimMarkerBuildOutput(status bool, code string, payload any) map[string]any {
return map[string]any{
"status": status,
"code": code,
"payload": payload,
}
}
// obrimMarkerTime executes the time marker workflow.
func obrimMarkerTime(config map[string]any) (any, string) {
markerConfig, code := obrimMarkerTimeConfig(config)
if code != "" {
return nil, code
}
marker, code := obrimMarkerTimeGenerate(markerConfig)
if code != "" {
return nil, code
}
return obrimMarkerTimePayload{
Marker: marker,
Epoch: markerConfig.Epoch,
Instance: markerConfig.Instance,
}, obrimMarkerSuccessTime
}
// obrimMarkerValidateTime validates time marker configuration.
func obrimMarkerValidateTime(config map[string]any) string {
epoch := obrimMarkerDefaultEpoch
if value, exists := config["epoch"]; exists {
parsed, ok := obrimMarkerInt64(value)
if !ok || parsed < 0 {
return obrimMarkerFailureInvalidEpoch
}
epoch = parsed
}
if epoch > time.Now().UnixNano() {
return obrimMarkerFailureInvalidEpoch
}
instance, exists := config["instance"]
if !exists {
return obrimMarkerFailureInvalidInstance
}
instanceValue, ok := instance.(string)
if !ok || strings.TrimSpace(instanceValue) == "" {
return obrimMarkerFailureInvalidInstance
}
return ""
}
// obrimMarkerTimeConfig builds the normalized time marker configuration.
func obrimMarkerTimeConfig(config map[string]any) (obrimMarkerTimeConfig, string) {
epoch := obrimMarkerDefaultEpoch
if value, exists := config["epoch"]; exists {
parsed, ok := obrimMarkerInt64(value)
if !ok || parsed < 0 || parsed > time.Now().UnixNano() {
return obrimMarkerTimeConfig{}, obrimMarkerFailureInvalidEpoch
}
epoch = parsed
}
instance, ok := config["instance"].(string)
if !ok || strings.TrimSpace(instance) == "" {
return obrimMarkerTimeConfig{}, obrimMarkerFailureInvalidInstance
}
return obrimMarkerTimeConfig{
Epoch: epoch,
Instance: strings.TrimSpace(instance),
}, ""
}
// obrimMarkerTimeGenerate generates a distributed time-based marker.
func obrimMarkerTimeGenerate(config obrimMarkerTimeConfig) (string, string) {
now := time.Now().UnixNano()
elapsed := now - config.Epoch
if elapsed < 0 {
return "", obrimMarkerFailureInvalidEpoch
}
marker := fmt.Sprintf(
"%x-%s",
elapsed,
config.Instance,
)
return marker, ""
}
// obrimMarkerRandom executes the random marker workflow.
func obrimMarkerRandom(config map[string]any) (any, string) {
markerConfig, code := obrimMarkerRandomConfig(config)
if code != "" {
return nil, code
}
marker, code := obrimMarkerRandomGenerate(markerConfig)
if code != "" {
return nil, code
}
return obrimMarkerRandomPayload{
Marker: marker,
Length: markerConfig.Length,
Charset: markerConfig.Charset,
}, obrimMarkerSuccessRandom
}
// obrimMarkerValidateRandom validates random marker configuration.
func obrimMarkerValidateRandom(config map[string]any) string {
length := obrimMarkerDefaultLength
if value, exists := config["length"]; exists {
parsed, ok := obrimMarkerInt(value)
if !ok || parsed <= 0 {
return obrimMarkerFailureInvalidLength
}
length = parsed
}
if length <= 0 {
return obrimMarkerFailureInvalidLength
}
charset := obrimMarkerDefaultCharset
if value, exists := config["charset"]; exists {
parsed, ok := value.(string)
if !ok || parsed == "" {
return obrimMarkerFailureInvalidCharset
}
charset = parsed
}
if charset == "" {
return obrimMarkerFailureInvalidCharset
}
return ""
}
// obrimMarkerRandomConfig builds the normalized random marker configuration.
func obrimMarkerRandomConfig(config map[string]any) (obrimMarkerRandomConfig, string) {
length := obrimMarkerDefaultLength
if value, exists := config["length"]; exists {
parsed, ok := obrimMarkerInt(value)
if !ok || parsed <= 0 {
return obrimMarkerRandomConfig{}, obrimMarkerFailureInvalidLength
}
length = parsed
}
charset := obrimMarkerDefaultCharset
if value, exists := config["charset"]; exists {
parsed, ok := value.(string)
if !ok || parsed == "" {
return obrimMarkerRandomConfig{}, obrimMarkerFailureInvalidCharset
}
charset = parsed
}
if charset == "" {
return obrimMarkerRandomConfig{}, obrimMarkerFailureInvalidCharset
}
return obrimMarkerRandomConfig{
Length: length,
Charset: charset,
}, ""
}
// obrimMarkerRandomGenerate generates a cryptographically secure random marker.
func obrimMarkerRandomGenerate(config obrimMarkerRandomConfig) (string, string) {
characters := []rune(config.Charset)
if len(characters) == 0 {
return "", obrimMarkerFailureInvalidCharset
}
randomBytes := make([]byte, config.Length)
if _, err := rand.Read(randomBytes); err != nil {
return "", obrimMarkerFailureGenerationError
}
marker := make([]rune, config.Length)
for index := range marker {
marker[index] = characters[int(randomBytes[index])%len(characters)]
}
return string(marker), ""
}
// obrimMarkerEncoded executes the encoded marker workflow.
func obrimMarkerEncoded(config map[string]any) (any, string) {
markerConfig, code := obrimMarkerEncodedConfig(config)
if code != "" {
return nil, code
}
marker, code := obrimMarkerEncodedGenerate(markerConfig)
if code != "" {
return nil, code
}
return obrimMarkerEncodedPayload{
Marker: marker,
Source: markerConfig.Data,
Length: markerConfig.Length,
}, obrimMarkerSuccessEncoded
}
// obrimMarkerValidateEncoded validates encoded marker configuration.
func obrimMarkerValidateEncoded(config map[string]any) string {
data, exists := config["data"]
if !exists {
return obrimMarkerFailureEmptySource
}
dataValue, ok := data.(string)
if !ok || strings.TrimSpace(dataValue) == "" {
return obrimMarkerFailureEmptySource
}
length := obrimMarkerDefaultLength
if value, exists := config["length"]; exists {
parsed, ok := obrimMarkerInt(value)
if !ok || parsed <= 0 {
return obrimMarkerFailureInvalidEncodingConfig
}
length = parsed
}
if length <= 0 {
return obrimMarkerFailureInvalidEncodingConfig
}
charset := obrimMarkerDefaultCharset
if value, exists := config["charset"]; exists {
parsed, ok := value.(string)
if !ok || parsed == "" {
return obrimMarkerFailureInvalidEncodingConfig
}
charset = parsed
}
if charset == "" {
return obrimMarkerFailureInvalidEncodingConfig
}
if value, exists := config["salt"]; exists {
if _, ok := value.(string); !ok {
return obrimMarkerFailureInvalidEncodingConfig
}
}
_ = length
_ = charset
return ""
}
// obrimMarkerEncodedConfig builds the normalized encoded marker configuration.
func obrimMarkerEncodedConfig(config map[string]any) (obrimMarkerEncodedConfig, string) {
data, ok := config["data"].(string)
if !ok || strings.TrimSpace(data) == "" {
return obrimMarkerEncodedConfig{}, obrimMarkerFailureEmptySource
}
length := obrimMarkerDefaultLength
if value, exists := config["length"]; exists {
parsed, valid := obrimMarkerInt(value)
if !valid || parsed <= 0 {
return obrimMarkerEncodedConfig{}, obrimMarkerFailureInvalidEncodingConfig
}
length = parsed
}
charset := obrimMarkerDefaultCharset
if value, exists := config["charset"]; exists {
parsed, valid := value.(string)
if !valid || parsed == "" {
return obrimMarkerEncodedConfig{}, obrimMarkerFailureInvalidEncodingConfig
}
charset = parsed
}
salt := ""
if value, exists := config["salt"]; exists {
parsed, valid := value.(string)
if !valid {
return obrimMarkerEncodedConfig{}, obrimMarkerFailureInvalidEncodingConfig
}
salt = parsed
}
return obrimMarkerEncodedConfig{
Data: data,
Length: length,
Charset: charset,
Salt: salt,
}, ""
}
// obrimMarkerEncodedGenerate generates a deterministic encoded marker.
func obrimMarkerEncodedGenerate(config obrimMarkerEncodedConfig) (string, string) {
characters := []rune(config.Charset)
if len(characters) == 0 {
return "", obrimMarkerFailureInvalidEncodingConfig
}
source := config.Data + config.Salt
digest := sha256.Sum256([]byte(source))
seed := binary.BigEndian.Uint64(digest[:8])
marker := make([]rune, config.Length)
for index := range marker {
seed = seed*6364136223846793005 + 1442695040888963407
marker[index] = characters[int(seed%uint64(len(characters)))]
}
return string(marker), ""
}
// obrimMarkerInt converts a supported value to int.
func obrimMarkerInt(value any) (int, bool) {
switch parsed := value.(type) {
case int:
return parsed, true
case int8:
return int(parsed), true
case int16:
return int(parsed), true
case int32:
return int(parsed), true
case int64:
return int(parsed), true
case uint:
return int(parsed), true
case uint8:
return int(parsed), true
case uint16:
return int(parsed), true
case uint32:
return int(parsed), true
case uint64:
if uint64(int(parsed)) != parsed {
return 0, false
}
return int(parsed), true
case float32:
if float32(int(parsed)) != parsed {
return 0, false
}
return int(parsed), true
case float64:
if float64(int(parsed)) != parsed {
return 0, false
}
return int(parsed), true
case string:
converted, err := strconv.Atoi(parsed)
if err != nil {
return 0, false
}
return converted, true
default:
return 0, false
}
}
// obrimMarkerInt64 converts a supported value to int64.
func obrimMarkerInt64(value any) (int64, bool) {
switch parsed := value.(type) {
case int:
return int64(parsed), true
case int8:
return int64(parsed), true
case int16:
return int64(parsed), true
case int32:
return int64(parsed), true
case int64:
return parsed, true
case uint:
if uint64(int64(parsed)) != uint64(parsed) {
return 0, false
}
return int64(parsed), true
case uint8:
return int64(parsed), true
case uint16:
return int64(parsed), true
case uint32:
return int64(parsed), true
case uint64:
if parsed > uint64(^uint64(0)>>1) {
return 0, false
}
return int64(parsed), true
case float32:
if float32(int64(parsed)) != parsed {
return 0, false
}
return int64(parsed), true
case float64:
if float64(int64(parsed)) != parsed {
return 0, false
}
return int64(parsed), true
case string:
converted, err := strconv.ParseInt(parsed, 10, 64)
if err != nil {
return 0, false
}
return converted, true
default:
return 0, false
}
}

375
essential/visible/service/helper/progress/progress.go
View File

@ -1,375 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Progress
|
| Purpose:
| - Manage, monitor, and report lifecycle-aware task progress through
| standardized progress tracking for countable and uncountable workflows.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use countable progress when tracking numeric progress using current
| and target values.
| - Use uncountable progress when tracking activity-based progress
| without percentage calculation.
| - Provide the lifecycle state through the state configuration value.
| - Provide current and target values when using countable progress.
|
| Example:
| - ObrimProgress("countable", map[string]any{
| "state": "running",
| "current": 50,
| "target": 100,
| })
|
| - ObrimProgress("uncountable", map[string]any{
| "state": "running",
| })
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package progress
import (
"math"
)
const (
obrimProgressTypeCountable = "countable"
obrimProgressTypeUncountable = "uncountable"
obrimProgressStateStarted = "started"
obrimProgressStateRunning = "running"
obrimProgressStateCompleted = "completed"
obrimProgressStateCanceled = "canceled"
obrimProgressSuccessStarted = "SUCCESS_STARTED"
obrimProgressSuccessRunning = "SUCCESS_RUNNING"
obrimProgressSuccessCompleted = "SUCCESS_COMPLETED"
obrimProgressSuccessCanceled = "SUCCESS_CANCELED"
obrimProgressFailureInvalidType = "FAILURE_INVALID_TYPE"
obrimProgressFailureMissingState = "FAILURE_MISSING_STATE"
obrimProgressFailureInvalidState = "FAILURE_INVALID_STATE"
obrimProgressFailureMissingCurrent = "FAILURE_MISSING_CURRENT"
obrimProgressFailureInvalidCurrent = "FAILURE_INVALID_CURRENT"
obrimProgressFailureMissingTarget = "FAILURE_MISSING_TARGET"
obrimProgressFailureInvalidTarget = "FAILURE_INVALID_TARGET"
obrimProgressFailureNonPositiveTarget = "FAILURE_NON_POSITIVE_TARGET"
)
type obrimProgressPayload struct {
Type string
State string
Current any
Target any
Percentage any
}
type obrimProgressOutput struct {
Status bool
Code string
Payload any
}
// ObrimProgress manages lifecycle-aware countable and uncountable progress.
func ObrimProgress(progressType string, config map[string]any) map[string]any {
if code := obrimProgressValidateInput(progressType, config); code != "" {
return obrimProgressBuildOutput(false, code, nil)
}
return obrimProgressRouteRequest(progressType, config)
}
// obrimProgressValidateInput validates the requested progress type and configuration.
func obrimProgressValidateInput(progressType string, config map[string]any) string {
switch progressType {
case obrimProgressTypeCountable:
state, exists := config["state"]
if !exists {
return obrimProgressFailureMissingState
}
stateValue, ok := state.(string)
if !ok {
return obrimProgressFailureInvalidState
}
switch stateValue {
case obrimProgressStateStarted,
obrimProgressStateRunning,
obrimProgressStateCompleted,
obrimProgressStateCanceled:
default:
return obrimProgressFailureInvalidState
}
if _, exists := config["current"]; !exists {
return obrimProgressFailureMissingCurrent
}
switch config["current"].(type) {
case int, int8, int16, int32, int64,
uint, uint8, uint16, uint32, uint64,
float32, float64:
default:
return obrimProgressFailureInvalidCurrent
}
if _, exists := config["target"]; !exists {
return obrimProgressFailureMissingTarget
}
switch config["target"].(type) {
case int, int8, int16, int32, int64,
uint, uint8, uint16, uint32, uint64,
float32, float64:
default:
return obrimProgressFailureInvalidTarget
}
target := 0.0
switch value := config["target"].(type) {
case int:
target = float64(value)
case int8:
target = float64(value)
case int16:
target = float64(value)
case int32:
target = float64(value)
case int64:
target = float64(value)
case uint:
target = float64(value)
case uint8:
target = float64(value)
case uint16:
target = float64(value)
case uint32:
target = float64(value)
case uint64:
target = float64(value)
case float32:
target = float64(value)
case float64:
target = value
}
if target <= 0 {
return obrimProgressFailureNonPositiveTarget
}
case obrimProgressTypeUncountable:
state, exists := config["state"]
if !exists {
return obrimProgressFailureMissingState
}
stateValue, ok := state.(string)
if !ok {
return obrimProgressFailureInvalidState
}
switch stateValue {
case obrimProgressStateStarted,
obrimProgressStateRunning,
obrimProgressStateCompleted,
obrimProgressStateCanceled:
default:
return obrimProgressFailureInvalidState
}
default:
return obrimProgressFailureInvalidType
}
return ""
}
// obrimProgressRouteRequest routes progress processing to its type-specific entry function.
func obrimProgressRouteRequest(progressType string, config map[string]any) map[string]any {
switch progressType {
case obrimProgressTypeCountable:
return obrimProgressCountable(config)
case obrimProgressTypeUncountable:
return obrimProgressUncountable(config)
default:
return obrimProgressBuildOutput(false, obrimProgressFailureInvalidType, nil)
}
}
// obrimProgressBuildOutput builds the standardized progress utility output.
func obrimProgressBuildOutput(status bool, code string, payload *obrimProgressPayload) map[string]any {
output := map[string]any{
"status": status,
"code": code,
"payload": nil,
}
if payload == nil {
return output
}
output["payload"] = map[string]any{
"type": payload.Type,
"state": payload.State,
"current": payload.Current,
"target": payload.Target,
"percentage": payload.Percentage,
}
return output
}
// obrimProgressCountable processes countable progress workflows.
func obrimProgressCountable(config map[string]any) map[string]any {
state := config["state"].(string)
var current float64
var target float64
switch value := config["current"].(type) {
case int:
current = float64(value)
case int8:
current = float64(value)
case int16:
current = float64(value)
case int32:
current = float64(value)
case int64:
current = float64(value)
case uint:
current = float64(value)
case uint8:
current = float64(value)
case uint16:
current = float64(value)
case uint32:
current = float64(value)
case uint64:
current = float64(value)
case float32:
current = float64(value)
case float64:
current = value
}
switch value := config["target"].(type) {
case int:
target = float64(value)
case int8:
target = float64(value)
case int16:
target = float64(value)
case int32:
target = float64(value)
case int64:
target = float64(value)
case uint:
target = float64(value)
case uint8:
target = float64(value)
case uint16:
target = float64(value)
case uint32:
target = float64(value)
case uint64:
target = float64(value)
case float32:
target = float64(value)
case float64:
target = value
}
percentage := int(math.Round((current / target) * 100))
if percentage < 0 {
percentage = 0
}
if percentage > 100 {
percentage = 100
}
code := obrimProgressSuccessRunning
switch state {
case obrimProgressStateStarted:
code = obrimProgressSuccessStarted
case obrimProgressStateRunning:
code = obrimProgressSuccessRunning
case obrimProgressStateCompleted:
code = obrimProgressSuccessCompleted
case obrimProgressStateCanceled:
code = obrimProgressSuccessCanceled
}
return obrimProgressBuildOutput(
true,
code,
&obrimProgressPayload{
Type: obrimProgressTypeCountable,
State: state,
Current: current,
Target: target,
Percentage: percentage,
},
)
}
// obrimProgressUncountable processes uncountable progress workflows.
func obrimProgressUncountable(config map[string]any) map[string]any {
state := config["state"].(string)
code := obrimProgressSuccessRunning
switch state {
case obrimProgressStateStarted:
code = obrimProgressSuccessStarted
case obrimProgressStateRunning:
code = obrimProgressSuccessRunning
case obrimProgressStateCompleted:
code = obrimProgressSuccessCompleted
case obrimProgressStateCanceled:
code = obrimProgressSuccessCanceled
}
return obrimProgressBuildOutput(
true,
code,
&obrimProgressPayload{
Type: obrimProgressTypeUncountable,
State: state,
Current: nil,
Target: nil,
Percentage: nil,
},
)
}

400
essential/visible/service/helper/retriever/retriever.go
View File

@ -1,400 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Retriever
|
| Purpose:
| - Retrieve data from supported resource handlers through a unified
| retrieval interface.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Use for retrieving data from registered JSON resource handlers.
| - Use type-based dispatching to route retrieval requests.
| - Use resource retrieval to obtain a complete JSON resource.
| - Use path retrieval to obtain a specific nested value.
| - Use fields retrieval to obtain multiple nested values.
| - Do not use path and fields retrieval together.
|
| Example:
| - ObrimRetriever("json", map[string]any{
| "resource": "metadata",
| })
|
| - ObrimRetriever("json", map[string]any{
| "resource": "metadata",
| "path": "app.name",
| })
|
| - ObrimRetriever("json", map[string]any{
| "resource": "metadata",
| "fields": []any{"app.name", "app.version"},
| })
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package retriever
import (
"fmt"
"strings"
"sync"
)
const (
// Utility type identifiers define supported retriever input types.
obrimRetrieverTypeJSON = "json"
// Retriever result codes define successful execution outcomes.
obrimRetrieverSuccessResource = "SUCCESS_RESOURCE_RETRIEVED"
obrimRetrieverSuccessPath = "SUCCESS_PATH_RETRIEVED"
obrimRetrieverSuccessFields = "SUCCESS_FIELDS_RETRIEVED"
// Retriever result codes define failed execution outcomes.
obrimRetrieverFailureInvalidType = "FAILURE_INVALID_TYPE"
obrimRetrieverFailureInvalidConfig = "FAILURE_INVALID_CONFIG"
obrimRetrieverFailureResourceRequired = "FAILURE_RESOURCE_REQUIRED"
obrimRetrieverFailurePathAndFields = "FAILURE_PATH_AND_FIELDS"
obrimRetrieverFailureInvalidPath = "FAILURE_INVALID_PATH"
obrimRetrieverFailureInvalidFields = "FAILURE_INVALID_FIELDS"
obrimRetrieverFailureResourceNotFound = "FAILURE_RESOURCE_NOT_FOUND"
obrimRetrieverFailureHandlerFailed = "FAILURE_HANDLER_FAILED"
obrimRetrieverFailurePathNotFound = "FAILURE_PATH_NOT_FOUND"
obrimRetrieverFailureFieldNotFound = "FAILURE_FIELD_NOT_FOUND"
obrimRetrieverFailureUnsupportedConfig = "FAILURE_UNSUPPORTED_CONFIG"
)
var (
// obrimRetrieverJsonHandlers stores registered JSON resource handlers.
obrimRetrieverJsonHandlers = map[string]func() map[string]any{}
// obrimRetrieverJsonHandlersMutex protects the JSON handler registry.
obrimRetrieverJsonHandlersMutex sync.RWMutex
)
// ObrimRetrieverResult represents the standardized retriever execution output.
type ObrimRetrieverResult struct {
Status bool `json:"status"`
Code string `json:"code"`
Payload map[string]any `json:"payload"`
}
// ObrimRetriever retrieves data from a supported resource handler.
func ObrimRetriever(
typ string,
config map[string]any,
) map[string]any {
if code := obrimRetrieverValidateInput(typ, config); code != "" {
return obrimRetrieverBuildOutput(false, code, nil)
}
return obrimRetrieverRouteRequest(typ, config)
}
// ObrimRetrieverJsonRegister registers a JSON resource handler.
func ObrimRetrieverJsonRegister(
resource string,
handler func() map[string]any,
) {
if strings.TrimSpace(resource) == "" || handler == nil {
return
}
obrimRetrieverJsonHandlersMutex.Lock()
defer obrimRetrieverJsonHandlersMutex.Unlock()
obrimRetrieverJsonHandlers[resource] = handler
}
// obrimRetrieverValidateInput validates the retriever type and configuration.
func obrimRetrieverValidateInput(
typ string,
config map[string]any,
) string {
switch typ {
case obrimRetrieverTypeJSON:
return obrimRetrieverValidateJSONConfig(config)
default:
return obrimRetrieverFailureInvalidType
}
}
// obrimRetrieverValidateJSONConfig validates JSON retriever configuration.
func obrimRetrieverValidateJSONConfig(config map[string]any) string {
if config == nil {
return obrimRetrieverFailureInvalidConfig
}
resourceValue, exists := config["resource"]
if !exists {
return obrimRetrieverFailureResourceRequired
}
resource, ok := resourceValue.(string)
if !ok || strings.TrimSpace(resource) == "" {
return obrimRetrieverFailureResourceRequired
}
_, hasPath := config["path"]
_, hasFields := config["fields"]
if hasPath && hasFields {
return obrimRetrieverFailurePathAndFields
}
for key := range config {
switch key {
case "resource", "path", "fields":
default:
return obrimRetrieverFailureUnsupportedConfig
}
}
if hasPath {
path, ok := config["path"].(string)
if !ok || strings.TrimSpace(path) == "" {
return obrimRetrieverFailureInvalidPath
}
}
if hasFields {
fields, ok := config["fields"].([]string)
if !ok || len(fields) == 0 {
return obrimRetrieverFailureInvalidFields
}
for _, field := range fields {
if strings.TrimSpace(field) == "" {
return obrimRetrieverFailureInvalidFields
}
}
}
return ""
}
// obrimRetrieverRouteRequest routes the request to its type-specific entry function.
func obrimRetrieverRouteRequest(
typ string,
config map[string]any,
) map[string]any {
switch typ {
case obrimRetrieverTypeJSON:
return obrimRetrieverJson(config)
default:
return obrimRetrieverBuildOutput(
false,
obrimRetrieverFailureInvalidType,
nil,
)
}
}
// obrimRetrieverBuildOutput builds the standardized retriever output.
func obrimRetrieverBuildOutput(
status bool,
code string,
payload map[string]any,
) map[string]any {
if !status {
payload = nil
}
return map[string]any{
"status": status,
"code": code,
"payload": payload,
}
}
// obrimRetrieverJson processes a JSON retrieval request.
func obrimRetrieverJson(config map[string]any) map[string]any {
resource := config["resource"].(string)
data, ok := obrimRetrieverJsonHandler(resource)
if !ok {
return obrimRetrieverBuildOutput(
false,
obrimRetrieverFailureResourceNotFound,
nil,
)
}
if pathValue, exists := config["path"]; exists {
path := pathValue.(string)
value, ok := obrimRetrieverJsonPath(data, path)
if !ok {
return obrimRetrieverBuildOutput(
false,
obrimRetrieverFailurePathNotFound,
nil,
)
}
return obrimRetrieverBuildOutput(
true,
obrimRetrieverSuccessPath,
map[string]any{
"data": value,
},
)
}
if fieldsValue, exists := config["fields"]; exists {
fields := fieldsValue.([]string)
values, ok := obrimRetrieverJsonFields(data, fields)
if !ok {
return obrimRetrieverBuildOutput(
false,
obrimRetrieverFailureFieldNotFound,
nil,
)
}
return obrimRetrieverBuildOutput(
true,
obrimRetrieverSuccessFields,
map[string]any{
"data": values,
},
)
}
return obrimRetrieverBuildOutput(
true,
obrimRetrieverSuccessResource,
map[string]any{
"data": obrimRetrieverJsonResource(data),
},
)
}
// obrimRetrieverJsonHandler locates and invokes a registered JSON handler.
func obrimRetrieverJsonHandler(
resource string,
) (map[string]any, bool) {
obrimRetrieverJsonHandlersMutex.RLock()
handler, exists := obrimRetrieverJsonHandlers[resource]
obrimRetrieverJsonHandlersMutex.RUnlock()
if !exists || handler == nil {
return nil, false
}
data := handler()
if data == nil {
return nil, false
}
return data, true
}
// obrimRetrieverJsonResource returns the complete JSON resource payload.
func obrimRetrieverJsonResource(
resource map[string]any,
) map[string]any {
return resource
}
// obrimRetrieverJsonPath retrieves a value using a dot-notation path.
func obrimRetrieverJsonPath(
resource map[string]any,
path string,
) (any, bool) {
parts := strings.Split(path, ".")
if len(parts) == 0 {
return nil, false
}
var current any = resource
for _, part := range parts {
if part == "" {
return nil, false
}
switch value := current.(type) {
case map[string]any:
next, exists := value[part]
if !exists {
return nil, false
}
current = next
case []any:
index := -1
for i, item := range value {
if part == strings.TrimSpace(part) {
var parsed int
if _, err := fmt.Sscanf(part, "%d", &parsed); err == nil {
index = parsed
}
}
if index >= 0 {
_ = item
break
}
break
}
if index < 0 || index >= len(value) {
return nil, false
}
current = value[index]
default:
return nil, false
}
}
return current, true
}
// obrimRetrieverJsonFields retrieves multiple values using field selection.
func obrimRetrieverJsonFields(
resource map[string]any,
fields []string,
) (map[string]any, bool) {
values := make(map[string]any, len(fields))
for _, field := range fields {
value, ok := obrimRetrieverJsonPath(resource, field)
if !ok {
return nil, false
}
values[field] = value
}
return values, true
}

114
essential/visible/service/helper/status/status.go
View File

@ -1,114 +0,0 @@
/*
|--------------------------------------------------------------------------
| Description
|--------------------------------------------------------------------------
|
| Name:
| - Status
|
| Purpose:
| - Provide a framework-level CLI status utility that standardizes
| terminal message presentation using semantic labels and visual
| indicators to ensure consistent output across all softwares.
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Instruction
|--------------------------------------------------------------------------
|
| Guideline:
| - Accept a semantic status category and human-readable message.
| - Use INFO, WARNING, SUCCESS, and ERROR as supported status labels.
| - Treat unsupported, empty, or invalid labels as INFO.
| - Emit exactly one standardized terminal message per invocation.
|
| Example:
| - ObrimStatus(
| "INFO",
| "Application started successfully.",
| )
|
| - ObrimStatus(
| "WARNING",
| "Configuration file not found.",
| )
|
| - ObrimStatus(
| "SUCCESS",
| "Installation completed.",
| )
|
| - ObrimStatus(
| "ERROR",
| "Unable to connect to the server.",
| )
|
|--------------------------------------------------------------------------
*/
/*
|--------------------------------------------------------------------------
| Credit
|--------------------------------------------------------------------------
|
| Contributor:
| - Rajon Ahmed
| - Blockonite
|
|--------------------------------------------------------------------------
*/
package status
import (
"fmt"
"strings"
)
// ObrimStatus emits a standardized terminal message.
func ObrimStatus(label, message string) {
normalizedLabel, normalizedMessage := obrimStatusValidateInput(label, message)
output := obrimStatusBuildOutput(obrimStatusFormatMessage(normalizedLabel, normalizedMessage))
fmt.Print(output)
}
// obrimStatusValidateInput normalizes and validates the status label and message.
func obrimStatusValidateInput(label, message string) (string, string) {
normalizedLabel := strings.ToUpper(strings.TrimSpace(label))
normalizedMessage := strings.TrimSpace(message)
switch normalizedLabel {
case "INFO", "WARNING", "SUCCESS", "ERROR":
default:
normalizedLabel = "INFO"
}
return normalizedLabel, normalizedMessage
}
// obrimStatusFormatMessage formats the status label and message with its visual indicator.
func obrimStatusFormatMessage(label, message string) string {
var indicator string
switch label {
case "WARNING":
indicator = "!"
case "SUCCESS":
indicator = "✓"
case "ERROR":
indicator = "✗"
default:
indicator = "ℹ"
}
return fmt.Sprintf("[%s %s] %s\n", indicator, label, message)
}
// obrimStatusBuildOutput builds the final terminal message.
func obrimStatusBuildOutput(message string) string {
return message
}