cacheHelper.go

@@ -7,15 +7,15 @@ import (
 	"github.com/allegro/bigcache"
 )
 
-
 const (
-	BIGCACHEShards=8
-	BIGCACHEMaxEntrySize=1024
-	BIGCACHEVerbose=true
-	BIGCACHEHardMaxCacheSize=0
-	BIGCACHEMaxEntriesInWindow=1000  10  60
-	BIGCACHELifeWindow=2
+	BIGCACHEShards             = 8
+	BIGCACHEMaxEntrySize       = 1024
+	BIGCACHEVerbose            = true
+	BIGCACHEHardMaxCacheSize   = 0
+	BIGCACHEMaxEntriesInWindow = 1000 * 10 * 60
+	BIGCACHELifeWindow         = 2
 )
+
 var bigcacheConfig = bigcache.Config{
 	// number of shards (must be a power of 2)
 	// Shards: 4096,
@@ -23,7 +23,7 @@ var bigcacheConfig = bigcache.Config{
 	// time after which entry can be evicted
 	LifeWindow: BIGCACHELifeWindow * time.Hour,
 	// rps * lifeWindow, used only in initial memory allocation
-	MaxEntriesInWindow: 1000 * 10 * 60,
+	MaxEntriesInWindow: BIGCACHEMaxEntriesInWindow,
 	// MaxEntriesInWindow: 10,
 	// max entry size in bytes, used only in initial memory allocation
 	MaxEntrySize: BIGCACHEMaxEntrySize,

compressionHelper.go

+package coreos
+
+import "github.com/DataDog/zstd"
+
+//Compress Compress
+func Compress(inputData []byte) ([]byte, error) {
+	compressedData, err := zstd.Compress(nil, inputData)
+
+	return compressedData, err
+}
+
+// Decompress  Decompress
+func Decompress(compressedData []byte) ([]byte, error) {
+	decompressedData, err := zstd.Decompress(nil, compressedData)
+	return decompressedData, err
+}

dalFDB.go

+package coreos
+
+import (
+	"fmt"
+
+	"time"
+
+)
+
+//GetDataFromFDB gets data from FDB
+func GetDataFromFDB(filePath string) ([]byte, error) {
+	data, err := ReadFile(filePath)
+	return data, err
+}
+
+//SaveDataToFDB saves data to FDB
+func SaveDataToFDB(filePath string, data []byte) error {
+	err := WriteFile(filePath, data)
+	fmt.Println(err)
+	return err
+}
+
+//DeleteFileFromFDB deletes file to FDB
+func DeleteFileFromFDB(filePath string) error {
+	newFilePath := filePath + "_deleted_" + time.Now().String()
+	err := RenameFile(filePath, newFilePath)
+	return err
+}

dalNoSQL.go

@@ -16,7 +16,7 @@ func GetMongoConnection() *mgo.Session {
 		Host := []string{
 			GetConfig("MONGODSN"),
 		}
-		const (
+		var (
 			Username = ""
 			Password = ""
 			Database = GetConfig("DBNAME")

glide.yaml

-package: coreospackage
+package: .
 import:
-- package: GolangFullStack/server/api/server/config
+- package: github.com/DataDog/zstd
+- package: github.com/OneOfOne/xxhash
 - package: github.com/allegro/bigcache
 - package: github.com/dgrijalva/jwt-go
-  version: ^3.0.0
 - package: github.com/garyburd/redigo
-  version: ^1.1.0
   subpackages:
   - redis
 - package: github.com/go-playground/locales
-  version: ^0.11.1
   subpackages:
   - en
 - package: github.com/go-playground/universal-translator
-  version: ^0.16.0
 - package: github.com/gocraft/dbr
-  version: ^2.1.0
 - package: github.com/labstack/echo
-  version: ^3.2.1
   subpackages:
   - middleware
 - package: github.com/sirupsen/logrus
-  version: ^1.0.0
-- package: github.com/spf13/viper
 - package: gopkg.in/go-playground/validator.v9
-  version: ^9.4.0
   subpackages:
   - translations/en
 - package: gopkg.in/mgo.v2
@@ -32,6 +24,5 @@ import:
   - bson
 testImport:
 - package: github.com/stretchr/testify
-  version: ^1.1.4
   subpackages:
   - assert

loggingHelper.go

@@ -11,38 +11,36 @@ var logger = logrus.New()
 func init() {
 	//log.Formatter = new(logger.JSONFormatter)
 	logger.Formatter = new(logrus.TextFormatter) // default
-	logger.Level = logrus.ErrorLevel
-
-	file, err := os.OpenFile("GolangFullStack.log", os.O_CREATE|os.O_APPEND, 0666)
+	logger.Level = logrus.InfoLevel
+	file, err := os.OpenFile("serverlogs.log", os.O_CREATE|os.O_APPEND, 0666)
 	if err == nil {
 		logger.Out = file
 	} else {
 		logger.Info("Failed to log to file, using default stderr")
 	}
-
 }
 
-//Debug Debug
-func Debug(message string) {
-	logger.Debug(message)
+//LogDebug Log Debug messages
+func LogDebug(args ...interface{}) {
+	logger.Debug(args)
 }
 
-//Info Info
-func Info(message string) {
-	logger.Info(message)
+//LogInfo Logs Info messages
+func LogInfo(args ...interface{}) {
+	logger.Info(args)
 }
 
-//Warn Warn
-func Warn(message string) {
-	logger.Warn(message)
+//LogWarn Logs Warning messages
+func LogWarn(args ...interface{}) {
+	logger.Warn(args)
 }
 
-//Error Error
-func Error(message string) {
-	logger.Error(message)
+//LogError Logs Error messages
+func LogError(args ...interface{}) {
+	logger.Error(args)
 }
 
-//Panic Panic
-func Panic(message string) {
-	logger.Panic(message)
+//LogPanic Logs Panic messages
+func LogPanic(args ...interface{}) {
+	logger.Panic(args)
 }

securityHelper.go

+package coreos
+
+import (
+	"bytes"
+	"crypto/aes"
+	"crypto/cipher"
+	"encoding/base64"
+
+	"github.com/OneOfOne/xxhash"
+)
+
+const (
+	IV = "AAAAAAAAAAAAAAAA"
+)
+
+//AESEncrypt Encrypts given text
+func AESEncrypt(plainText, key []byte) []byte {
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	padding := block.BlockSize() - len(plainText)%block.BlockSize()
+
+	padtext := bytes.Repeat([]byte{byte(padding)}, padding)
+
+	plainText = append(plainText, padtext...)
+
+	cipherText := make([]byte, len(plainText))
+
+	cbc := cipher.NewCBCEncrypter(block, []byte(IV))
+	cbc.CryptBlocks(cipherText, plainText)
+
+	encodedData := make([]byte, base64.StdEncoding.EncodedLen(len(plainText)))
+
+	base64.StdEncoding.Encode(encodedData, cipherText)
+
+	return encodedData
+}
+
+//AESDecrypt Decrypts given cipher text
+func AESDecrypt(encodedData, key []byte) []byte {
+	decodedData := make([]byte, base64.StdEncoding.DecodedLen(len(encodedData)))
+	n, err := base64.StdEncoding.Decode(decodedData, encodedData)
+	if err != nil {
+		panic(err)
+	}
+
+	cipherText := decodedData[:n]
+
+	block, err := aes.NewCipher(key)
+	if err != nil {
+		panic(err)
+	}
+
+	cbc := cipher.NewCBCDecrypter(block, []byte(IV))
+	cbc.CryptBlocks(cipherText, cipherText)
+
+	length := len(cipherText)
+
+	unpadding := int(cipherText[length-1])
+
+	return cipherText[:(length - unpadding)]
+}
+
+//GetHashChecksumOfByteArray Get Hash Check sum
+func GetHashChecksumOfByteArray(byteArray []byte) uint64 {
+	h := xxhash.New64()
+	h.Write(byteArray)
+	return h.Sum64()
+}
+
+//GetHashChecksumOfFile Get Hash Check sum
+func GetHashChecksumOfFile(filePath string) uint64 {
+	byteArray, err := ReadFile(filePath)
+	if err != nil {
+		hash := GetHashChecksumOfByteArray(byteArray)
+		return hash
+	}
+
+	return 0
+}

validationHelper.go

@@ -4,6 +4,7 @@ import (
 	"github.com/go-playground/locales/en"
 
 	ut "github.com/go-playground/universal-translator"
+	validator "gopkg.in/go-playground/validator.v9"
 	en_translations "gopkg.in/go-playground/validator.v9/translations/en"
 )