routebuildermdl.go

package routebuildermdl

import (
	"io/ioutil"
	"mime/multipart"
	"net/http"
	"strings"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"

	"github.com/gin-gonic/gin"
)

// Init routing init
func Init(o, r, c *gin.RouterGroup) {
	o.POST("/mql", OpenHandler)
	r.POST("/mql", RestrictedHandler)
	c.POST("/mql", RoleBasedHandler)
}

func setResponseHeader(serviceName string) responseData {
	rd := responseData{}
	val, ok := GetResponseHeader(serviceName)
	if ok {
		rd.ResponseHeader = val
	}
	return rd
}

func isMultipartRequest(header string) bool {
	return strings.HasPrefix(header, "multipart/form-data")
}

func executeService(name string, data []byte, isForm bool, formData *multipart.Form, isRestricted, isRoleBased bool) (interface{}, error) {
	var service interface{}
	var found bool
	if isRestricted {
		if isRoleBased {
			service, found = roleBasedServices.Get(name)
		} else {
			service, found = restrictedServices.Get(name)
		}
	} else {
		service, found = openServices.Get(name)
	}
	if !found {
		return nil, errormdl.Wrap("Service Not Found: " + name)
	}

	if isForm {
		serviceCache := service.(ServiceCache)
		return serviceCache.FormService(formData)
	}
	serviceCache := service.(ServiceCache)
	if serviceCache.IsFormService {
		return nil, errormdl.Wrap("Form_Header_Missing")
	}
	if serviceCache.IsMasterService {
		return serviceCache.MasterService.Run(nil)
	}
	return serviceCache.Service(data)
}

func commonHandler(c *gin.Context, isRestricted, isRoleBased bool) {
	service := c.Request.Header.Get("Service-Header")
	header := c.Request.Header.Get("Content-Type")
	responseDataObj := setResponseHeader(service)
	if isMultipartRequest(header) {
		form, multiPartError := c.MultipartForm()
		if errormdl.CheckErr(multiPartError) != nil {
			responseDataObj.Error = errormdl.CheckErr(multiPartError).Error()
			c.JSON(http.StatusExpectationFailed, responseDataObj)
			return
		}
		result, err := executeService(service, nil, true, form, isRestricted, isRoleBased)
		if errormdl.CheckErr1(err) != nil {
			responseDataObj.Error = errormdl.CheckErr1(err).Error()
			c.JSON(http.StatusExpectationFailed, responseDataObj)
			return
		}
		responseDataObj.Result = result
		c.JSON(http.StatusOK, responseDataObj)
		return
	}
	var reqBody []byte
	if c.Request.Body != nil {
		var readError error
		reqBody, readError = ioutil.ReadAll(c.Request.Body)
		if errormdl.CheckErr2(readError) != nil {
			responseDataObj.Error = errormdl.CheckErr2(readError).Error()
			c.JSON(http.StatusExpectationFailed, responseDataObj)
			return
		}
	}
	result, err := executeService(service, reqBody, false, nil, isRestricted, isRoleBased)
	if errormdl.CheckErr3(err) != nil {
		responseDataObj.Error = errormdl.CheckErr3(err).Error()
		c.JSON(http.StatusExpectationFailed, responseDataObj)
		return
	}
	responseDataObj.Result = result
	c.JSON(http.StatusOK, responseDataObj)
	return

}

// OpenHandler for /o
func OpenHandler(c *gin.Context) {
	commonHandler(c, false, false)
}

// RestrictedHandler for /r
func RestrictedHandler(c *gin.Context) {
	commonHandler(c, true, false)
}

// RoleBasedHandler for /r/c
func RoleBasedHandler(c *gin.Context) {
	commonHandler(c, true, true)
}