diff --git a/authhelper/jwtHelper.go b/authhelper/jwtHelper.go
index 9dec84f468954a2fc0412a06e1ac6a893b8b2ea3..01c9f6be496007062e8738fc8f63a534c7d62b17 100644
--- a/authhelper/jwtHelper.go
+++ b/authhelper/jwtHelper.go
@@ -30,19 +30,23 @@ func GetJwtConfig() middleware.JWTConfig {
 }
 
 // DecodeToken decode token
-func DecodeToken(tokenFromRequest string) jwt.MapClaims {
+func DecodeToken(tokenFromRequest string) (jwt.MapClaims, error) {
 	tokenFromRequest = strings.Trim(strings.Split(tokenFromRequest, "Bearer")[1], " ")
 	// get data i.e.Claims from token
-	token, _ := jwt.Parse(tokenFromRequest, func(token *jwt.Token) (interface{}, error) {
+	token, err := jwt.Parse(tokenFromRequest, func(token *jwt.Token) (interface{}, error) {
 		// Don't forget to validate the alg is what you expect:
-		if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
+		_, ok := token.Method.(*jwt.SigningMethodRSA)
+		if !ok {
 			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
 		}
 		return JwtKey, nil
 	})
+	if err != nil {
+		return nil, err
+	}
 	claims, ok := token.Claims.(jwt.MapClaims)
 	if !ok {
-		return nil
+		return nil, nil
 	}
-	return claims
+	return claims, nil
 }
diff --git a/cachehelper/cacheHelper.go b/cachehelper/cacheHelper.go
index b687e554c56f24cbc6df7e2530dcfa7a78fe54e4..39f80e1fe74614cb84eb7837ecdefcff661b22a0 100644
--- a/cachehelper/cacheHelper.go
+++ b/cachehelper/cacheHelper.go
@@ -1,9 +1,9 @@
 package cachehelper
 
 import (
-	"fmt"
 	"time"
 
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/coreospackage/logginghelper"
 	"github.com/allegro/bigcache"
 )
 
@@ -12,7 +12,7 @@ const (
 	BIGCACHEMaxEntrySize       = 1024
 	BIGCACHEVerbose            = true
 	BIGCACHEHardMaxCacheSize   = 0
-	BIGCACHEMaxEntriesInWindow = 1000 * 10 * 60
+	BIGCACHEMaxEntriesInWindow = 100000
 	BIGCACHELifeWindow         = 2
 )
 
@@ -47,8 +47,8 @@ func GetValue(key string) ([]byte, error) {
 }
 
 //SetValue SetValue
-func SetValue(key string, value []byte) {
-	cache.Set(key, value)
+func SetValue(key string, value []byte) error {
+	return cache.Set(key, value)
 }
 
 //GetLength GetLength
@@ -59,5 +59,5 @@ func GetLength() int {
 //Callback function executed when cache element is removed.
 //Executed only when onRemove of cache config poting to this function
 func onRemove(key string, entry []byte) {
-	fmt.Println(key + " removed at " + time.Now().String())
+	logginghelper.LogInfo(key + " removed at " + time.Now().String())
 }
diff --git a/coreos.go b/coreos.go
new file mode 100644
index 0000000000000000000000000000000000000000..f9f98ef86b924e4ccfa90b725304786c19a16e06
--- /dev/null
+++ b/coreos.go
@@ -0,0 +1,4 @@
+package coreos
+
+//This file is included to avoid error-
+//"package corelab.mkcl.org/MKCLOS/coredevelopmentplatform/coreospackage: no buildable Go source files"
diff --git a/dalhelper/dalFDB.go b/dalhelper/dalFDB.go
index b1a82abc54b4c9a258cef8fda5cbd14e41f48a89..9da9d986e6b0b2ca2720c6b40267618cf592704d 100644
--- a/dalhelper/dalFDB.go
+++ b/dalhelper/dalFDB.go
@@ -1,8 +1,6 @@
 package dalhelper
 
 import (
-	"fmt"
-
 	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/coreospackage/filehelper"
 
 	"time"
@@ -10,14 +8,13 @@ import (
 
 //GetDataFromFDB gets data from FDB
 func GetDataFromFDB(filePath string) ([]byte, error) {
-	data, errr := filehelper.ReadFile(filePath)
-	return data, errr
+	data, err := filehelper.ReadFile(filePath)
+	return data, err
 }
 
 //SaveDataToFDB saves data to FDB
 func SaveDataToFDB(filePath string, data []byte) error {
 	err := filehelper.WriteFile(filePath, data)
-	fmt.Println(err)
 	return err
 }
 
diff --git a/dalhelper/dalMySQL.go b/dalhelper/dalMySQL.go
index f835f1bc7ac396eaaebaa87accc4ebc81ac734a4..8512e45fedc70a638ecb21127dc245d06c23609f 100644
--- a/dalhelper/dalMySQL.go
+++ b/dalhelper/dalMySQL.go
@@ -10,17 +10,20 @@ import (
 
 // Hold a single global connection (pooling provided by sql driver)
 var sqlConnection *dbr.Connection
+var connectionError error
 var sqlOnce sync.Once
 
 //GetSQLConnection to db
 func GetSQLConnection() (*dbr.Connection, error) {
 	sqlOnce.Do(func() {
 		// create a connection db(e.g. "postgres", "mysql", or "sqlite3")
-		connection, _ := dbr.Open("mysql", confighelper.GetConfig("MysqlDSN"), nil)
-
+		connection, err := dbr.Open("mysql", confighelper.GetConfig("MysqlDSN"), nil)
+		if err != nil {
+			connectionError = err
+		}
 		//	connection.SetMaxIdleConns(10)
 		//	connection.SetMaxOpenConns(5)
 		sqlConnection = connection
 	})
-	return sqlConnection, nil
+	return sqlConnection, connectionError
 }
diff --git a/dalhelper/dalNoSQL.go b/dalhelper/dalNoSQL.go
index 9700bf888e245787a62ae8f3d6b0300f1e25af06..0e1bd3224f2bdb31393ef8d8a66fd26385a9f523 100644
--- a/dalhelper/dalNoSQL.go
+++ b/dalhelper/dalNoSQL.go
@@ -1,7 +1,6 @@
 package dalhelper
 
 import (
-	"fmt"
 	"sync"
 
 	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/coreospackage/confighelper"
@@ -10,10 +9,11 @@ import (
 )
 
 var instance *mgo.Session
+var sessionError error
 var once sync.Once
 
 //GetMongoConnection method
-func GetMongoConnection() *mgo.Session {
+func GetMongoConnection() (*mgo.Session, error) {
 	once.Do(func() {
 		Host := []string{
 			confighelper.GetConfig("MONGODSN"),
@@ -31,14 +31,12 @@ func GetMongoConnection() *mgo.Session {
 			Database: Database,
 		})
 		if err != nil {
-
+			sessionError = err
 		}
 		//defer session.Close()
 
-		fmt.Printf("Connected to replica set %v!\n", session.LiveServers())
-
 		instance = session
 
 	})
-	return instance
+	return instance, sessionError
 }
diff --git a/filehelper/fileHelper.go b/filehelper/fileHelper.go
index 0ca81cbe11837ab9404d8bfed98c7dd81980d0ab..76496dda11bf4a12c0f76d357b2644ccb3905fc9 100644
--- a/filehelper/fileHelper.go
+++ b/filehelper/fileHelper.go
@@ -79,7 +79,7 @@ func Zip(source, target string) error {
 
 	info, err := os.Stat(source)
 	if err != nil {
-		return nil
+		return err
 	}
 
 	var baseDir string
@@ -122,6 +122,8 @@ func Zip(source, target string) error {
 		}
 		defer file.Close()
 		_, err = io.Copy(writer, file)
+		if err != nil {
+		}
 		return err
 	})
 
@@ -135,7 +137,8 @@ func Unzip(archive, target string) error {
 		return err
 	}
 
-	if err := os.MkdirAll(target, 0755); err != nil {
+	err = os.MkdirAll(target, 0755)
+	if err != nil {
 		return err
 	}
 
@@ -158,7 +161,8 @@ func Unzip(archive, target string) error {
 		}
 		defer targetFile.Close()
 
-		if _, err := io.Copy(targetFile, fileReader); err != nil {
+		_, err = io.Copy(targetFile, fileReader)
+		if err != nil {
 			return err
 		}
 	}
@@ -185,7 +189,8 @@ func CopyFile(source, destination string) error {
 		return err
 	}
 	err = ioutil.WriteFile(destination, data, 0644)
-
+	if err != nil {
+	}
 	return err
 }
 
@@ -193,7 +198,8 @@ func CopyFile(source, destination string) error {
 func ReplaceFile(data []byte, destination string) error {
 
 	err := ioutil.WriteFile(destination, data, 0644)
-
+	if err != nil {
+	}
 	return err
 }
 
@@ -247,14 +253,12 @@ func FileSearch(fileName, path string) ([]string, error) {
 func findFile(path string, fileInfo os.FileInfo, err error) error {
 
 	if err != nil {
-
 		return err
 	}
 
 	// get absolute path of the folder that we are searching
 	absolute, err := filepath.Abs(path)
 	if err != nil {
-
 		return err
 	}
 
diff --git a/logginghelper/loggingHelper.go b/logginghelper/loggingHelper.go
index 07401468c40f999887703cccb37856417f7258e9..4de152bb5e70f5dd4f7d8b69f617524239c0819c 100644
--- a/logginghelper/loggingHelper.go
+++ b/logginghelper/loggingHelper.go
@@ -1,46 +1,255 @@
 package logginghelper
 
 import (
+	"fmt"
 	"os"
+	"runtime"
+	"strings"
 
 	"github.com/sirupsen/logrus"
 )
 
 var logger = logrus.New()
+var consoleLogger = logrus.New()
+
+// Fields wraps logrus.Fields, which is a map[string]interface{}
+type Fields logrus.Fields
+
+//Init  Init Logger
+func Init(fileName string) {
+
+	customFormatter := new(logrus.TextFormatter)
+	customFormatter.TimestampFormat = "2006-01-02 15:04:05"
 
-func init() {
 	//log.Formatter = new(logger.JSONFormatter)
-	logger.Formatter = new(logrus.TextFormatter) // default
+	logger.Formatter = customFormatter // default
 	logger.Level = logrus.InfoLevel
-	file, err := os.OpenFile("serverlogs.log", os.O_CREATE|os.O_APPEND, 0666)
+
+	file, err := os.OpenFile(fileName, os.O_CREATE|os.O_RDWR|os.O_APPEND, 0666)
+
 	if err == nil {
 		logger.Out = file
 	} else {
 		logger.Info("Failed to log to file, using default stderr")
 	}
+
+	//console logger
+	//log.Formatter = new(logger.JSONFormatter)
+	consoleLogger.Formatter = customFormatter // default
+	consoleLogger.Level = logrus.InfoLevel
+	consoleLogger.Out = os.Stdout
+
 }
 
-//LogDebug Log Debug messages
+//SetLogLevel SetLogLevel
+func SetLogLevel(level logrus.Level) {
+	logger.Level = level
+	consoleLogger.Level = level
+}
+
+//SetLogFormatter SetLogFormatter
+func SetLogFormatter(formatter logrus.Formatter) {
+	logger.Formatter = formatter
+	consoleLogger.Formatter = formatter
+}
+
+// LogDebug logs a message at level Debug on the standard logger.
 func LogDebug(args ...interface{}) {
-	logger.Debug(args)
+	if logger.Level >= logrus.DebugLevel {
+		entry := logger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Debug(args)
+	}
+	//console logger
+	if consoleLogger.Level >= logrus.DebugLevel {
+		entry := consoleLogger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Debug(args)
+	}
 }
 
-//LogInfo Logs Info messages
+// LogDebugWithFields logs a message with fields at level Debug on the standard logger.
+func LogDebugWithFields(l interface{}, f Fields) {
+	if logger.Level >= logrus.DebugLevel {
+		entry := logger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Debug(l)
+	}
+
+	//console logger
+	if consoleLogger.Level >= logrus.DebugLevel {
+		entry := consoleLogger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Debug(l)
+	}
+}
+
+// LogInfo logs a message at level Info on the standard logger.
 func LogInfo(args ...interface{}) {
-	logger.Info(args)
+	if logger.Level >= logrus.InfoLevel {
+		entry := logger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Info(args...)
+	}
+
+	//console logger
+	if consoleLogger.Level >= logrus.InfoLevel {
+		entry := consoleLogger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Info(args...)
+	}
 }
 
-//LogWarn Logs Warning messages
+// LogInfoWithFields logs a message with fields at level Debug on the standard logger.
+func LogInfoWithFields(l interface{}, f Fields) {
+	if logger.Level >= logrus.InfoLevel {
+		entry := logger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Info(l)
+	}
+
+	//console logger
+	if consoleLogger.Level >= logrus.InfoLevel {
+		entry := consoleLogger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Info(l)
+	}
+}
+
+// LogWarn logs a message at level Warn on the standard logger.
 func LogWarn(args ...interface{}) {
-	logger.Warn(args)
+	if logger.Level >= logrus.WarnLevel {
+		entry := logger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Warn(args...)
+	}
+
+	//console logger
+	if consoleLogger.Level >= logrus.WarnLevel {
+		entry := consoleLogger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Warn(args...)
+	}
 }
 
-//LogError Logs Error messages
+// LogWarnWithFields logs a message with fields at level Debug on the standard logger.
+func LogWarnWithFields(l interface{}, f Fields) {
+	if logger.Level >= logrus.WarnLevel {
+		entry := logger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Warn(l)
+	}
+	//console logger
+	if consoleLogger.Level >= logrus.WarnLevel {
+		entry := consoleLogger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Warn(l)
+	}
+
+}
+
+// LogError logs a message at level Error on the standard logger.
 func LogError(args ...interface{}) {
-	logger.Error(args)
+	if logger.Level >= logrus.ErrorLevel {
+		entry := logger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Error(args...)
+	}
+	//console logger
+
+	if consoleLogger.Level >= logrus.ErrorLevel {
+		entry := consoleLogger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Error(args...)
+	}
+}
+
+// LogErrorWithFields logs a message with fields at level Debug on the standard logger.
+func LogErrorWithFields(l interface{}, f Fields) {
+	if logger.Level >= logrus.ErrorLevel {
+		entry := logger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Error(l)
+	}
+	//console logger
+	if consoleLogger.Level >= logrus.ErrorLevel {
+		entry := consoleLogger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Error(l)
+	}
+}
+
+// LogFatal logs a message at level Fatal on the standard logger.
+func LogFatal(args ...interface{}) {
+	if logger.Level >= logrus.FatalLevel {
+		entry := logger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Fatal(args...)
+	}
+	//console logger
+	if consoleLogger.Level >= logrus.FatalLevel {
+		entry := consoleLogger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Fatal(args...)
+	}
 }
 
-//LogPanic Logs Panic messages
+// LogFatalWithFields logs a message with fields at level Debug on the standard logger.
+func LogFatalWithFields(l interface{}, f Fields) {
+	if logger.Level >= logrus.FatalLevel {
+		entry := logger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Fatal(l)
+	}
+	//console logger
+	if consoleLogger.Level >= logrus.FatalLevel {
+		entry := consoleLogger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Fatal(l)
+	}
+
+}
+
+// Panic logs a message at level Panic on the standard logger.
 func LogPanic(args ...interface{}) {
-	logger.Panic(args)
+	if logger.Level >= logrus.PanicLevel {
+		entry := logger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Panic(args...)
+	}
+	//console logger
+	if consoleLogger.Level >= logrus.PanicLevel {
+		entry := consoleLogger.WithFields(logrus.Fields{})
+		entry.Data["file"] = fileInfo(2)
+		entry.Panic(args...)
+	}
+}
+
+// LogPanicWithFields logs a message with fields at level Debug on the standard logger.
+func LogPanicWithFields(l interface{}, f Fields) {
+	if logger.Level >= logrus.PanicLevel {
+		entry := logger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Panic(l)
+	}
+	//console logger
+	if consoleLogger.Level >= logrus.PanicLevel {
+		entry := consoleLogger.WithFields(logrus.Fields(f))
+		entry.Data["file"] = fileInfo(2)
+		entry.Panic(l)
+	}
+}
+
+func fileInfo(skip int) string {
+	_, file, line, ok := runtime.Caller(skip)
+	if !ok {
+		file = "<???>"
+		line = 1
+	} else {
+		slash := strings.LastIndex(file, "/")
+		if slash >= 0 {
+			file = file[slash+1:]
+		}
+	}
+	return fmt.Sprintf("%s:%d", file, line)
 }
diff --git a/notificationhelper/smsHelper.go b/notificationhelper/smsHelper.go
index 49c81d7c8ea38e597b1ef97df905b909076e3f00..d9b0240454e64e993f3cd8442a8bc9f962108eb6 100644
--- a/notificationhelper/smsHelper.go
+++ b/notificationhelper/smsHelper.go
@@ -1,11 +1,10 @@
 package notificationhelper
 
 import (
-	"fmt"
-	"io/ioutil"
-	"log"
 	"net/http"
 	"net/url"
+
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/coreospackage/confighelper"
 )
 
 type SMS struct {
@@ -20,17 +19,19 @@ type SMS struct {
 // SendSMS : send SMS Service
 func SendSMS(smsObject SMS) error {
 	var postURL string
-	postURL = GetConfig("SMSAPIURL") + "?UserName=" + smsObject.UserName + "&password=" + smsObject.Password + "&MobileNo=" + smsObject.MobileNumber + "&SenderID=" + smsObject.SenderID + "&CDMAHeader=" + smsObject.CDMAHeader + "&Message=" + url.QueryEscape(smsObject.Message)
-	// fmt.Println(postURL)
+	postURL = confighelper.GetConfig("SMSAPIURL") + "?UserName=" + smsObject.UserName + "&password=" + smsObject.Password + "&MobileNo=" + smsObject.MobileNumber + "&SenderID=" + smsObject.SenderID + "&CDMAHeader=" + smsObject.CDMAHeader + "&Message=" + url.QueryEscape(smsObject.Message)
+
 	resp, err := http.Get(postURL)
 	if err != nil {
-		// handle error
-		log.Fatal(err)
+		return err
 	}
 	defer resp.Body.Close()
-	body, err := ioutil.ReadAll(resp.Body)
-	fmt.Println(body)
-	return err
+	// body, err := ioutil.ReadAll(resp.Body)
+	// if err != nil {
+	// 	return err
+	// }
+
+	return nil
 }
 
 // GetSMSObject : get sms object
diff --git a/securityhelper/compressionHelper.go b/securityhelper/compressionHelper.go
index 54ab679aeca15395b7bba1a813820049ec7eb89e..43289c442923ce2b105d1ccba7259420c89a3341 100644
--- a/securityhelper/compressionHelper.go
+++ b/securityhelper/compressionHelper.go
@@ -5,7 +5,6 @@ import "github.com/DataDog/zstd"
 //Compress Compress
 func Compress(inputData []byte) ([]byte, error) {
 	compressedData, err := zstd.Compress(nil, inputData)
-
 	return compressedData, err
 }
 
diff --git a/securityhelper/securityHelper.go b/securityhelper/securityHelper.go
index 35cc43b1fe5c27679364424375fc7851ea1f3434..c13e6715d90e0760467b359d44168caeda97984a 100644
--- a/securityhelper/securityHelper.go
+++ b/securityhelper/securityHelper.go
@@ -6,6 +6,8 @@ import (
 	"crypto/cipher"
 	"encoding/base64"
 
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/coreospackage/filehelper"
+
 	"github.com/OneOfOne/xxhash"
 )
 
@@ -14,10 +16,10 @@ const (
 )
 
 //AESEncrypt Encrypts given text
-func AESEncrypt(plainText, key []byte) []byte {
+func AESEncrypt(plainText, key []byte) ([]byte, error) {
 	block, err := aes.NewCipher(key)
 	if err != nil {
-		panic(err)
+		return nil, err
 	}
 
 	padding := block.BlockSize() - len(plainText)%block.BlockSize()
@@ -35,7 +37,7 @@ func AESEncrypt(plainText, key []byte) []byte {
 
 	base64.StdEncoding.Encode(encodedData, cipherText)
 
-	return encodedData
+	return encodedData, nil
 }
 
 //AESDecrypt Decrypts given cipher text
@@ -64,19 +66,24 @@ func AESDecrypt(encodedData, key []byte) []byte {
 }
 
 //GetHashChecksumOfByteArray Get Hash Check sum
-func GetHashChecksumOfByteArray(byteArray []byte) uint64 {
+func GetHashChecksumOfByteArray(byteArray []byte) (uint64, error) {
 	h := xxhash.New64()
-	h.Write(byteArray)
-	return h.Sum64()
+	_, err := h.Write(byteArray)
+	if err != nil {
+		return 0, err
+	}
+	return h.Sum64(), nil
 }
 
 //GetHashChecksumOfFile Get Hash Check sum
-func GetHashChecksumOfFile(filePath string) uint64 {
-	byteArray, err := ReadFile(filePath)
-	if err == nil {
-		hash := GetHashChecksumOfByteArray(byteArray)
-		return hash
+func GetHashChecksumOfFile(filePath string) (uint64, error) {
+	byteArray, err := filehelper.ReadFile(filePath)
+	if err != nil {
+		return 0, err
 	}
-
-	return 0
+	hash, err := GetHashChecksumOfByteArray(byteArray)
+	if err != nil {
+		return 0, err
+	}
+	return hash, nil
 }
diff --git a/validationhelper/validationHelper.go b/validationhelper/validationHelper.go
index 7742a12b1542d5517f28259b27efd9db58b90332..2bbe7e7bed5fb8277f01254f6bb6096bb743649f 100644
--- a/validationhelper/validationHelper.go
+++ b/validationhelper/validationHelper.go
@@ -16,17 +16,13 @@ func Validate(s interface{}) map[string]string {
 	validate = validator.New()
 
 	en := en.New()
-	//mr := mr.New()
-
 	uni = ut.New(en, en)
 
 	trans, _ := uni.GetTranslator("en")
 	en_translations.RegisterDefaultTranslations(validate, trans)
-	// mr_translations.RegisterDefaultTranslations(validate, trans)
 
 	//For custom error message
 	// validate.RegisterTranslation("required", trans, func(ut ut.Translator) error {
-	// 	// fmt.Println(ut)
 	// 	return ut.Add("required", "{0} must have a value!", true) // see universal-translator for details
 
 	// }, func(ut ut.Translator, fe validator.FieldError) string {
@@ -36,19 +32,14 @@ func Validate(s interface{}) map[string]string {
 	// })
 
 	err := validate.Struct(s)
-
 	if err != nil {
 		errs := err.(validator.ValidationErrors)
-
-		//customErrs := map[string]string{}
 		customErrs := make(map[string]string, len(errs))
 
 		for _, e := range errs {
 			// can translate each error one at a time.
 			customErrs[e.Namespace()] = e.Translate(trans)
-
 		}
-
 		return customErrs
 	}
 	return nil