Skip to content
Snippets Groups Projects
Select Git revision
  • 76f36d59b5843fa468d1d52f6e03ea52e34eac7b
  • main default protected
  • trading_hours
  • refactor_trading_hours
  • audit_cleaning_cater_for_non_struct_fields
  • remove-info-logs
  • sl-refactor
  • 18-use-scan-for-param-values
  • 17-order-search-results
  • 4-simplify-framework-2
  • 1-http-error
  • v1.297.0
  • v1.296.0
  • v1.295.0
  • v1.294.0
  • v1.293.0
  • v1.292.0
  • v1.291.0
  • v1.290.0
  • v1.289.0
  • v1.288.0
  • v1.287.0
  • v1.286.0
  • v1.285.0
  • v1.284.0
  • v1.283.0
  • v1.282.0
  • v1.281.0
  • v1.280.0
  • v1.279.0
  • v1.278.0
31 results

string_utils.go

Blame
  • string_utils.go 4.74 KiB
    package string_utils
    
    import (
    	_ "crypto/md5"
    	"encoding/json"
    	"fmt"
    	"regexp"
    	"strconv"
    	"strings"
    	"unicode"
    
    	"golang.org/x/text/runes"
    	"golang.org/x/text/transform"
    	"golang.org/x/text/unicode/norm"
    )
    
    // ReplaceNonSpacingMarks removes diacritics e.g. êžů becomes ezu
    func ReplaceNonSpacingMarks(str string) string {
    	t := transform.Chain(norm.NFD, runes.Remove(runes.In(unicode.Mn)), norm.NFC) // Mn: non-spacing marks
    	result, _, _ := transform.String(t, str)
    	return result
    }
    
    func RemoveAllWhiteSpaces(s string) string {
    	return strings.ReplaceAll(strings.ReplaceAll(s, " ", ""), "\t", "")
    }
    
    func ReplaceCaseInsensitive(string, toReplace, replaceWith string) string {
    	regex := regexp.MustCompile("(?i)" + strings.ToLower(toReplace))
    	return regex.ReplaceAllString(string, replaceWith)
    }
    
    // TrimQuotes - trims quotes from a string (ie: "foo" will return foo)
    func TrimQuotes(stringToTrim string) string {
    	if len(stringToTrim) >= 2 {
    		if stringToTrim[0] == '"' && stringToTrim[len(stringToTrim)-1] == '"' {
    			return stringToTrim[1 : len(stringToTrim)-1]
    		}
    	}
    
    	return stringToTrim
    }
    
    // IsNumericString returns true if the string can be converted to a float without error
    func IsNumericString(s string) bool {
    	_, err := strconv.ParseFloat(s, 64)
    	return err == nil
    }
    
    // StandardisePhoneNumber standardises phone numbers with +27 instead of 0 prefix
    func StandardisePhoneNumber(number string) string {
    	// is the first rune/char of the string a 0
    	if []rune(number)[0] == []rune("0")[0] {
    		// Add south african country code (hardcoded for now)
    		number = "+27" + number[1:]
    	}
    	return number
    }
    
    func FormatPhoneNumber(phoneNumber string) string {
    	if len(phoneNumber) > 7 {
    		return phoneNumber
    	}
    
    	// Format as 076 453 2188
    	phoneNumber = insertInto(phoneNumber, 3, " ")
    	phoneNumber = insertInto(phoneNumber, 7, " ")
    	return phoneNumber
    }
    
    func insertInto(s string, index int, characters string) string {
    	return s[:index] + characters + s[index:]
    }
    
    func IsAlphaNumeric(str string) bool {
    	regex := regexp.MustCompile("^[a-zA-Z0-9]*$")
    	return regex.MatchString(str)
    }
    
    func IsAlphaNumericOrDash(str string) bool {
    	regex := regexp.MustCompile("^[a-zA-Z0-9-]*$")
    	return regex.MatchString(str)
    }
    
    func Equal(a string, b string) bool {
    	return strings.TrimSpace(strings.ToLower(a)) == strings.TrimSpace(strings.ToLower(b))
    }
    
    func UnwrapString(s *string) string {
    	if s == nil {
    		return ""
    	}
    	return *s
    }
    
    // TrimP trims specified strings, replacing empty string with nil
    func TrimP(sp *string) *string {
    	if sp == nil {
    		return nil
    	}
    	s := strings.TrimSpace(*sp)
    	if s == "" {
    		return nil
    	}
    	return &s
    }
    
    // ConcatP concatenates all specified non-empty strings with ", " separators
    func ConcatP(args ...*string) string {
    	s := ""
    	for _, arg := range args {
    		if arg != nil && *arg != "" {
    			if s != "" {
    				s += ", "
    			}
    			s += *arg
    		}
    	}
    	return s
    }
    
    func ToJSONString(object interface{}) (string, error) {
    	jsonBytes, err := json.Marshal(&object)
    	if err != nil {
    		return "", err
    	}
    	return string(jsonBytes), nil
    }
    
    func Int64ToString(number int64) string {
    	return strconv.FormatInt(number, 10)
    }
    
    func IntToString(number int) string {
    	return strconv.Itoa(number)
    }
    
    func Int64SliceToString(numbers []int64) string {
    	numString := fmt.Sprint(numbers)
    	numString = strings.Join(strings.Split(numString, " "), ",")
    	return numString
    }
    
    func StringToInt64(stringValue string) (int64, error) {
    	number, err := strconv.ParseInt(stringValue, 10, 64)
    	return number, err
    }
    
    func StringToFloat64(stringValue string) (float64, error) {
    	number, err := strconv.ParseFloat(stringValue, 64)
    	if err != nil {
    		return 0, err
    	}
    	return number, nil
    }
    
    func Float64ToString(number float64, precision int) string {
    	return strconv.FormatFloat(number, 'f', precision, 64)
    }
    
    func Float64ToStringWithPrec(number float64, prec int) string {
    	return strconv.FormatFloat(number, 'f', prec, 64)
    }
    
    func ValidateStringAsInt64(stringValue string) error {
    	_, err := StringToInt64(stringValue)
    	return err
    }
    
    func PtoString(stringPointer *string) string {
    	if stringPointer == nil {
    		return ""
    	}
    
    	return *stringPointer
    }
    
    func IsEmpty(sp *string) bool {
    	if sp == nil {
    		return true
    	}
    
    	return len(*sp) == 0
    }
    
    // StringTrimQuotes - trims quotes from a string (ie: "foo" will return foo)
    func StringTrimQuotes(stringToTrim string) string {
    	if len(stringToTrim) >= 2 {
    		if stringToTrim[0] == '"' && stringToTrim[len(stringToTrim)-1] == '"' {
    			return stringToTrim[1 : len(stringToTrim)-1]
    		}
    	}
    
    	return stringToTrim
    }
    
    
    func KeyToHumanReadable(s string) string {
    	s = strings.TrimSpace(s)
    
    	re := regexp.MustCompile("(_|-)")
    	s = re.ReplaceAllString(s, " ")
    
    	return sentenceCase(string(s))
    }
    
    func sentenceCase(str string) string {
    	for i, v := range str {
    		return string(unicode.ToUpper(v)) + str[i+1:]
    	}
    	return ""
    }