validationmdl.go

package validationmdl

import (
	"errors"
	"net/url"

	"github.com/tidwall/gjson"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/loggermdl"
	requestValidator "corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/validationmdl/validationcore"
	govalidator "github.com/asaskevich/govalidator"
)

// var cnt int

// //ValidateRequest func validates the given model
// func ValidateRequest(httpRequest *http.Request, validationRules, validationMessages requestValidator.MapData) map[string]interface{} {

// 	cnt++
// 	//Get the content type of the request as validations for content types are different
// 	contentType := httpRequest.Header.Get("Content-Type")

// 	//Initialize the validation errors as blank
// 	var validationErrors url.Values

// 	//Set validator options
// 	opts := requestValidator.Options{
// 		Request: httpRequest,
// 		Rules:   validationRules,
// 	}

// 	//Set custom validation messages if sent from user
// 	if validationMessages != nil {
// 		opts.Messages = validationMessages
// 	}

// 	if contentType == "application/json" || contentType == "text/plain" {
// 		//Validate request type json and text (RAW data from request)
// 		data := make(map[string]interface{}, 0)
// 		opts.Data = &data
// 		validator := requestValidator.New(opts)
// 		validationErrors = validator.ValidateJSON()

// 	} else {
// 		//Validate request type form-data, form-urlencoded
// 		validator := requestValidator.New(opts)
// 		validationErrors = validator.Validate()
// 	}

// 	if len(validationErrors) > 0 {
// 		errs := map[string]interface{}{"validationErrors": validationErrors}
// 		return errs
// 	}
// 	return nil
// }

// // ValidateStruct validates the structures with govalidator
// func ValidateStruct(structToValidate interface{}) error {
// 	validationResult, err := govalidator.ValidateStruct(structToValidate)
// 	if err != nil {
// 		return err
// 	}
// 	if !errormdl.CheckBool(validationResult) {
// 		return errors.New("ERROR:ValidateStruct function error")
// 	}
// 	return nil
// }

// //ValidateJSONData to validate JSON data
// func ValidateJSONData(jsonData []byte, validationRules, validationMessages requestValidator.MapData) map[string]interface{} {

// 	//Initialize the validation errors as blank
// 	var validationErrors url.Values

// 	//Set validator options
// 	opts := requestValidator.Options{
// 		Rules:    validationRules,
// 		JSONData: jsonData,
// 	}

// 	//Set custom validation messages if sent from user
// 	if validationMessages != nil {
// 		opts.Messages = validationMessages
// 	}

// 	validator := requestValidator.New(opts)
// 	validationErrors = validator.ValidateJSONData()

// 	if len(validationErrors) > 0 {
// 		errs := map[string]interface{}{"validationErrors": validationErrors}
// 		return errs
// 	}

// 	return nil
// }

// ValidateJSONString to validate JSON data
func ValidateJSONString(jsonString string, validationRules, validationMessages requestValidator.MapData) map[string]interface{} {

	var validationErrors url.Values

	opts := requestValidator.Options{
		Rules: validationRules,
	}
	data, ok := gjson.Parse(jsonString).Value().(map[string]interface{})
	if !ok {
		loggermdl.LogError("can not cast to map")
		return nil
	}
	opts.Data = data

	validator := requestValidator.New(opts)
	validationErrors = validator.ValidateJSONString()

	if len(validationErrors) > 0 {
		errs := map[string]interface{}{"validationErrors": validationErrors}
		return errs
	}
	return nil
}

// ValidateGJSONResult to validate JSON data
func ValidateGJSONResult(rs *gjson.Result, validationRules, validationMessages requestValidator.MapData) map[string]interface{} {
	var validationErrors url.Values
	opts := requestValidator.Options{
		Rules: validationRules,
	}
	data, ok := rs.Value().(map[string]interface{})
	if !ok {
		loggermdl.LogError("can not cast to map", rs.Value())
		return map[string]interface{}{"error": "cannot cast to map"}
	}
	opts.Data = data

	validator := requestValidator.New(opts)
	validationErrors = validator.ValidateJSONString()
	if len(validationErrors) > 0 {
		errs := map[string]interface{}{"validationErrors": validationErrors}
		return errs
	}
	return nil
}

// ValidateStruct validates the structures with govalidator
func ValidateStruct(structToValidate interface{}) error {
	validationResult, err := govalidator.ValidateStruct(structToValidate)
	if err != nil {
		return err
	}
	if !errormdl.CheckBool(validationResult) {
		return errors.New("ERROR:ValidateStruct function error")
	}
	return nil
}