utils

Utils

A Set of useful functions for working with files, date, errors and strings.

Casts

set of helper function for safe cast value as numeric and boolean type!

CastBoolE

Try to parse value as bool or return error.

// Signature:
CastBoolE(v interface{}) (bool, error)

CastBool

Try to parse value as bool or return fallback.

// Signature:
CastBool(v interface{}, fallback bool) bool

CastIntE

Try to parse value as int or return error.

// Signature:
CastIntE(v interface{}) (int, error)

CastInt

Try to parse value as int or return fallback.

// Signature:
CastInt(v interface{}, fallback int) int

CastInt8E

Try to parse value as int8 or return error.

// Signature:
CastInt8E(v interface{}) (int8, error)

CastInt8

Try to parse value as int8 or return fallback.

// Signature:
CastInt8(v interface{}, fallback int8) int8

CastInt16E

Try to parse value as int16 or return error.

// Signature:
CastInt16E(v interface{}) (int16, error)

CastInt16

Try to parse value as int16 or return fallback.

// Signature:
CastInt16(v interface{}, fallback int16) int16

CastInt32E

Try to parse value as int32 or return error.

// Signature:
CastInt32E(v interface{}) (int32, error)

CastInt32

Try to parse value as int32 or return fallback.

// Signature:
CastInt32(v interface{}, fallback int32) int32

CastInt64E

Try to parse value as int64 or return error.

// Signature:
CastInt64E(v interface{}) (int64, error)

CastInt64

Try to parse value as int64 or return fallback.

// Signature:
CastInt64(v interface{}, fallback int64) int64

CastUIntE

Try to parse value as uint or return error.

// Signature:
CastUIntE(v interface{}) (uint, error)

CastUInt

Try to parse value as uint or return fallback.

// Signature:
CastUInt(v interface{}, fallback uint) uint

CastUInt8E

Try to parse value as uint8 or return error.

// Signature:
CastUInt8E(v interface{}) (uint8, error)

CastUInt8

Try to parse value as uint8 or return fallback.

// Signature:
CastUInt8(v interface{}, fallback uint8) uint8

CastUInt16E

Try to parse value as uint16 or return error.

// Signature:
CastUInt16E(v interface{}) (uint16, error)

CastUInt16

Try to parse value as uint16 or return fallback.

// Signature:
CastUInt16(v interface{}, fallback uint16) uint16

CastUInt32E

Try to parse value as uint32 or return error.

// Signature:
CastUInt32E(v interface{}) (uint32, error)

CastUInt32

Try to parse value as uint32 or return fallback.

// Signature:
CastUInt32(v interface{}, fallback uint32) uint32

CastUInt64E

Try to parse value as uint64 or return error.

// Signature:
CastUInt64E(v interface{}) (uint64, error)

CastUInt64

Try to parse value as uint64 or return fallback.

// Signature:
CastUInt64(v interface{}, fallback uint64) uint64

CastFloat64E

Try to parse value as float64 or return error.

// Signature:
CastFloat64E(v interface{}) (float64, error)

CastFloat64

Try to parse value as float64 or return fallback.

// Signature:
CastFloat64(v interface{}, fallback float64) float64

Error

TaggedError

Generate a tagged error.

// Signature:
TaggedError(tags []string, format string, args ...interface{}) error

// Example:
TaggedError([]string{"MyLib","MyMethod"}, "failed on %s file!", "main.json")
// [MyLib] [MyMethod] failed on main.json file!

IsErrorOf

Check if error has tag.

// Signature:
IsErrorOf(tag string, err error) bool

// Example:
IsErrorOf("MyLib", err) // true

HasError

Check if error is nil or not.

// Signature:
HasError(err error) bool

PanicOnError

Generate panic from error if error not nil.

// Signature:
PanicOnError(err error)

Handle Functions Return Value

This set of functions help you to handle output of function that have a return type with error value. this functions generate panic on error or return value. You can use this functions instead of if else block for checking error.

// Signature:
UIntOrPanic(res uint, err error) uint
UInt8OrPanic(res uint8, err error) uint8
UInt16OrPanic(res uint16, err error) uint16
UInt32OrPanic(res uint32, err error) uint32
UInt64OrPanic(res uint64, err error) uint64
IntOrPanic(res int, err error) int
Int8OrPanic(res int8, err error) int8
Int16OrPanic(res int16, err error) int16
Int32OrPanic(res int32, err error) int32
Int64OrPanic(res int64, err error) int64
Float32OrPanic(res float32, err error) float32
Float64OrPanic(res float64, err error) float64
StringOrPanic(res string, err error) string
BoolOrPanic(res bool, err error) bool
InterfaceOrPanic(res interface{}, err error) interface{}

// Example:
import "github.com/bopher/utils"
func TestIt(a int, b int) (int, error) { ... }
res = utils.IntOrPanic(TestIt(1, 3))

File

FileExists

Check if file exists or not.

// Signature:
FileExists(path string) (bool, error)

// Example:
import "github.com/bopher/utils"
exists, err := utils.FileExists("path/to/file")

IsDirectory

Check if path is a directory.

// Signature:
IsDirectory(path string) (bool, error)

// Example
import "github.com/bopher/utils"
ok, err := utils.IsDirectory("path/to/dir")

FindFile

Search for files in directory by a regex pattern.

// Signature:
FindFile(dir string, pattern string) []string

// Example:
import "github.com/bopher/utils"
files := utils.FindFile("path/to/dir", ".+\.sql") // => Get All file with sql extension

ClearDirectory

Delete all files and sub-directory in directory.

// Signature:
ClearDirectory(dir string) error

GetSubDirectory

Get list of sub directories.

// Signature:
GetSubDirectory(dir string) ([]string, error)

CreateDirectory

Create nested directory.

// Signature:
CreateDirectory(path string) error

// Example:
import "github.com/bopher/utils"
err := utils.CreateDirectory("a/b/c/d") // => Create all a, b, c and d directory

String

ExtractNumbers

Extract numbers from string.

import "github.com/bopher/utils"
numbers := utils.ExtractNumbers("(+1) 234-56789") // => 123456789

RandomStringFromCharset

Generate random string from character list.

import "github.com/bopher/utils"
str, err := utils.RandomStringFromCharset(5, "1234567890") // => "59102"
str2, err2 := utils.RandomStringFromCharset(3, "ABCDEFGH") // => "DFC"

RandomString

Generate random string from Alpha-Num Chars

import "github.com/bopher/utils"
str, err := utils.RandomString(5) // => "AB5S2"

Slugify

Generate dash separated string.

import "github.com/bopher/utils"
str := utils.Slugify("welcome to", "my site") // => "welcome-to-my-site"

ConcatStr

Join strings with separator.

// Signature:
ConcatStr(sep string, str ...string) string

// Example:
import "github.com/bopher/utils"
str := utils.ConcatStr(" ", "John", "", "Doe") // => "John Doe"

FormatNumber

Format number with comma separator.

import "github.com/bopher/utils"
str := utils.FormatNumber("total: $ %d", 12500000) // => "total: $ 12,500,000"

Mongo DB

MongoArray

Generate primitive.A array from args.

import "github.com/bopher/utils"
m := utils.MongoArray("John", "Kim", "Jimmy") // => ["John", "Kim", "Jimmy"]

MongoMap

Generate primitive.M structure from args. Args count must be even!

import "github.com/bopher/utils"
m := utils.MongoMap("_id", 1, "name", "John") // => { _id: 1, name: "John"}

MongoMaps

generate []primitive.M from args. Args count must be even!

import "github.com/bopher/utils"
m := utils.MongoMaps("_id", 1, "name", "John") // => [{ _id: 1}, {name: "John"}]

MongoDoc

Generate primitive.D from args. Args count must be even!

import "github.com/bopher/utils"
m := utils.MongoDoc("_id", 1, "name", "John") // => [{Key: "_id", Value: 1}, {Key: "name", Value: "John"}]

MongoOr

Generate mongo $or.

import "github.com/bopher/utils"
orCond := utils.MongoOr(utils.MongoMaps("_id", 1, "name", "John")) // => {$or: [{ _id: 1}, {name: "John"}]}

MongoAnd

Generate mongo $and.

import "github.com/bopher/utils"
andCond := utils.MongoAnd(utils.MongoMaps("_id", 1, "name", "John")) // => {$and: [{ _id: 1}, {name: "John"}]}

MongoIn

Generate mongo $in.

import "github.com/bopher/utils"
inCond := utils.MongoIn("name", []int{1,2,3}) // => {name: {$in: [1,2,3]}}

MongoSet

Generate mongo $set.

import "github.com/bopher/utils"
setVal := utils.MongoSet(utils.MongoMap("name", "John")) // => {$set: {name: "John"}}

MongoNestedSet

Generate nested mongo $set with key/value.

import "github.com/bopher/utils"
setVal := utils.MongoNestedSet("name", "John") // => {$set: {name: "John"}}

MongoMatch

Generate mongo $match.

import "github.com/bopher/utils"
match := utils.MongoMatch(utils.MongoMap("name", "John")) // => {$match: {name: "John"}}

MongoLimit

Generate mongo $limit.

import "github.com/bopher/utils"
limit := utils.MongoLimit(2) // => {$limit: 2}

MongoSort

Generate mongo $sort.

import "github.com/bopher/utils"
sorts := utils.MongoSort(utils.MongoMap({"_id", 1})) // => {$sort: {_id:1}}

MongoSkip

Generate mongo $skip.

import "github.com/bopher/utils"
sorts := utils.MongoSkip(30)) // => {$skip: 30}

MongoLookup

Generate mongo $lookup.

import "github.com/bopher/utils"
lookup := utils.MongoLookup("users", "user_id", "_id", "user"))
// => {
//     $lookup: {
//         from: "users",
//         localField: "user_id",
//         foreignField: "_id",
//         as: "user"
//     }
// }

MongoUnwind

Generate mongo $unwind (with preserveNull).

import "github.com/bopher/utils"
unwind := utils.MongoUnwind("invoices"))
// => {
//     $unwind: {
//         path: "invoices",
//         preserveNullAndEmptyArrays: true,
//     }
// }

MongoUnwrap

Get first item of array and insert to doc using $addFields.

import "github.com/bopher/utils"
unwrapped := utils.MongoUnwrap("logins", "first_login")) // => {$addFields: {first_login: {$first: logins}}}

MongoGroup

Generate mongo $group.

import "github.com/bopher/utils"
group := utils.MongoGroup(utils.MongoMap("_id", "$_id", "last_login", utils.MongoMap("$last", "$logins"))))
// => {
//     $group:{
//         _id: $_id,
//         last_login: {$last: $logins}
//     }
// }

MongoSetRoot

Generate mongo $replaceRoot.

import "github.com/bopher/utils"
setRoot := utils.MongoSetRoot("$_record")) // => {$replaceRoot: {newRoot: $_record}}

MongoMergeRoot

Generate $replaceRoot with $mergeObject.

import "github.com/bopher/utils"
mergeRoot := utils.MongoMergeRoot("$_record", "$$ROOT")) // => {$replaceRoot: {newRoot: {$mergeObjects: ["$_record", "$$ROOT"]}}}

MongoUnProject

Generate $project to remove fields from result.

import "github.com/bopher/utils"
unProject := utils.MongoUnProject("_record", "referral")) // => {$project: {_record:0, referral: 0 }}

ParseObjectID

Parse object id from string. This function return nil if object id is invalid!

import "github.com/bopher/utils"
oId := utils.ParseObjectID("6184011af9530d2ec143ae38")

IsValidOId

Check if object id is valid and not zero.

import "github.com/bopher/utils"
valid := utils.IsValidOId(oIdObject)