From 06dd220143ab0a83fb114085fe7b5e10dbae4af9 Mon Sep 17 00:00:00 2001 From: Simon Waldherr Date: Tue, 23 Jul 2024 21:25:56 +0200 Subject: [PATCH] minor changes in as package --- as/as.go | 103 +++++++++++++++++++++++++ as/example_test.go | 184 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 287 insertions(+) diff --git a/as/as.go b/as/as.go index 2fa96f5..b75816b 100755 --- a/as/as.go +++ b/as/as.go @@ -2,7 +2,9 @@ package as import ( + "encoding/json" "fmt" + "reflect" "regexp" "strconv" "strings" @@ -490,3 +492,104 @@ func DBTypeMultiple(val []string) string { } return regex[typeint].typ } + +// HexToRGB converts a hex color string to its RGB components. +func HexToRGB(hex string) (int, int, int, error) { + hex = strings.TrimPrefix(hex, "#") + if len(hex) != 6 { + return 0, 0, 0, fmt.Errorf("invalid hex color length") + } + r, err := strconv.ParseInt(hex[0:2], 16, 64) + if err != nil { + return 0, 0, 0, err + } + g, err := strconv.ParseInt(hex[2:4], 16, 64) + if err != nil { + return 0, 0, 0, err + } + b, err := strconv.ParseInt(hex[4:6], 16, 64) + if err != nil { + return 0, 0, 0, err + } + return int(r), int(g), int(b), nil +} + +// RGBToHex converts RGB components to a hex color string. +func RGBToHex(r, g, b int) string { + return fmt.Sprintf("#%02x%02x%02x", r, g, b) +} + +// MapToStruct converts a map to a struct based on the given struct type. +func MapToStruct(m map[string]interface{}, result interface{}) error { + for k, v := range m { + structValue := reflect.ValueOf(result).Elem() + structFieldValue := structValue.FieldByName(strings.Title(k)) + if !structFieldValue.IsValid() { + continue + } + if !structFieldValue.CanSet() { + continue + } + val := reflect.ValueOf(v) + if structFieldValue.Type() != val.Type() { + return fmt.Errorf("provided value type didn't match struct field type") + } + structFieldValue.Set(val) + } + return nil +} + +// StructToMap converts a struct to a map. +func StructToMap(input interface{}) map[string]interface{} { + output := make(map[string]interface{}) + val := reflect.ValueOf(input) + typ := reflect.TypeOf(input) + for i := 0; i < val.NumField(); i++ { + output[typ.Field(i).Name] = val.Field(i).Interface() + } + return output +} + +// IsEmailValid validates an email address using a regex. +func IsEmailValid(email string) bool { + re := regexp.MustCompile(`^[a-z0-9._%+\-]+@[a-z0-9.\-]+\.[a-z]{2,}$`) + return re.MatchString(email) +} + +// IsURLValid validates a URL using a regex. +func IsURLValid(url string) bool { + re := regexp.MustCompile(`^(https?://)?([a-z0-9.-]+)\.([a-z.]{2,6})([/\w .-]*)*/?$`) + return re.MatchString(url) +} + +// IsCreditCardValid validates a credit card number using the Luhn algorithm. +func IsCreditCardValid(cardNumber string) bool { + var sum int + alt := false + for i := len(cardNumber) - 1; i > -1; i-- { + n, _ := strconv.Atoi(string(cardNumber[i])) + if alt { + n *= 2 + if n > 9 { + n -= 9 + } + } + sum += n + alt = !alt + } + return sum%10 == 0 +} + +// ToJSON converts a Go value to a JSON string. +func ToJSON(value interface{}) (string, error) { + jsonBytes, err := json.Marshal(value) + if err != nil { + return "", err + } + return string(jsonBytes), nil +} + +// FromJSON converts a JSON string to a Go value. +func FromJSON(jsonStr string, result interface{}) error { + return json.Unmarshal([]byte(jsonStr), result) +} diff --git a/as/example_test.go b/as/example_test.go index 1597c68..bcfa95c 100755 --- a/as/example_test.go +++ b/as/example_test.go @@ -153,3 +153,187 @@ func ExampleType_json() { // email: foobar@example.tld // price: 15€ } + +func ExampleHexToRGB() { + values := []string{"#ff5733", "#00ff00", "#0000ff", "123456"} + + fmt.Println("as.HexToRGB()") + for _, v := range values { + r, g, b, err := as.HexToRGB(v) + if err != nil { + fmt.Printf("%v => error: %v\n", v, err) + } else { + fmt.Printf("%v => R: %d, G: %d, B: %d\n", v, r, g, b) + } + } + + // Output: + // as.HexToRGB() + // #ff5733 => R: 255, G: 87, B: 51 + // #00ff00 => R: 0, G: 255, B: 0 + // #0000ff => R: 0, G: 0, B: 255 + // 123456 => R: 18, G: 52, B: 86 +} + +func ExampleRGBToHex() { + values := [][]int{{255, 87, 51}, {0, 255, 0}, {0, 0, 255}} + + fmt.Println("as.RGBToHex()") + for _, v := range values { + hex := as.RGBToHex(v[0], v[1], v[2]) + fmt.Printf("R: %d, G: %d, B: %d => %v\n", v[0], v[1], v[2], hex) + } + + // Output: + // as.RGBToHex() + // R: 255, G: 87, B: 51 => #ff5733 + // R: 0, G: 255, B: 0 => #00ff00 + // R: 0, G: 0, B: 255 => #0000ff +} + +func ExampleMapToStruct() { + type Person struct { + Name string + Age int + } + + values := []map[string]interface{}{ + {"Name": "Alice", "Age": 30}, + {"Name": "Bob", "Age": 25}, + } + + fmt.Println("as.MapToStruct()") + for _, v := range values { + var person Person + err := as.MapToStruct(v, &person) + if err != nil { + fmt.Printf("%v => error: %v\n", v, err) + } else { + fmt.Printf("%v => %+v\n", v, person) + } + } + + // Output: + // as.MapToStruct() + // map[Age:30 Name:Alice] => {Name:Alice Age:30} + // map[Age:25 Name:Bob] => {Name:Bob Age:25} +} + +func ExampleStructToMap() { + type Person struct { + Name string + Age int + } + + values := []Person{ + {Name: "Alice", Age: 30}, + {Name: "Bob", Age: 25}, + } + + fmt.Println("as.StructToMap()") + for _, v := range values { + m := as.StructToMap(v) + fmt.Printf("%+v => %v\n", v, m) + } + + // Output: + // as.StructToMap() + // {Name:Alice Age:30} => map[Age:30 Name:Alice] + // {Name:Bob Age:25} => map[Age:25 Name:Bob] +} + +func ExampleIsEmailValid() { + values := []string{"test@example.com", "invalid-email", "user@domain.co", "name@domain"} + + fmt.Println("as.IsEmailValid()") + for _, v := range values { + valid := as.IsEmailValid(v) + fmt.Printf("%v => %v\n", v, valid) + } + + // Output: + // as.IsEmailValid() + // test@example.com => true + // invalid-email => false + // user@domain.co => true + // name@domain => false +} + +func ExampleIsURLValid() { + values := []string{"http://example.com", "https://www.google.com", "invalid-url", "ftp://example.com"} + + fmt.Println("as.IsURLValid()") + for _, v := range values { + valid := as.IsURLValid(v) + fmt.Printf("%v => %v\n", v, valid) + } + + // Output: + // as.IsURLValid() + // http://example.com => true + // https://www.google.com => true + // invalid-url => false + // ftp://example.com => false +} + +func ExampleIsCreditCardValid() { + values := []string{"4111111111111111", "5500000000000004", "1234567890123456", "378282246310005"} + + fmt.Println("as.IsCreditCardValid()") + for _, v := range values { + valid := as.IsCreditCardValid(v) + fmt.Printf("%v => %v\n", v, valid) + } + + // Output: + // as.IsCreditCardValid() + // 4111111111111111 => true + // 5500000000000004 => true + // 1234567890123456 => false + // 378282246310005 => true +} + +func ExampleToJSON() { + values := []interface{}{"foobar", 123, true, map[string]interface{}{"key": "value"}} + + fmt.Println("as.ToJSON()") + for _, v := range values { + jsonStr, err := as.ToJSON(v) + if err != nil { + fmt.Printf("%v => error: %v\n", v, err) + } else { + fmt.Printf("%v => %v\n", v, jsonStr) + } + } + + // Output: + // as.ToJSON() + // foobar => "foobar" + // 123 => 123 + // true => true + // map[key:value] => {"key":"value"} +} + +func ExampleFromJSON() { + type Person struct { + Name string + Age int + } + values := []string{`{"Name": "Alice", "Age": 30}`, `{"Name": "Bob", "Age": 25}`} + + fmt.Println("as.FromJSON()") + for _, v := range values { + var person Person + err := as.FromJSON(v, &person) + if err != nil { + fmt.Printf("%v => error: %v\n", v, err) + } else { + fmt.Printf("%v => %+v\n", v, person) + } + } + + // Output: + // as.FromJSON() + // {"Name": "Alice", "Age": 30} => {Name:Alice Age:30} + // {"Name": "Bob", "Age": 25} => {Name:Bob Age:25} +}