route builder module

dalmdl/fdb/fdb_test.go

@@ -278,3 +278,51 @@ func TestAppendDataToFDBWithoutQueue(t *testing.T) {
 	err := AppendDataToFDBWithoutQueue("../../testingdata/users.json", ba, false)
 	assert.NoError(t, err, "No Error Expected")
 }
+
+func Test7SaveDataToFDBWithoutQueue(t *testing.T) {
+	Fastcache.Purge()
+	ba, _ := getDataFromFDB("../../testingdata/users.json")
+	EnableSecurity([]byte("MKCLSecurity$#@!"), "AAAAAAAAAAAAAAAA")
+	err := SaveDataToFDBWithoutQueue("../../testingdata/users_enc1.json", ba, true, false)
+	DisableSecurity()
+	fmt.Println(GetSecurityStatus())
+	assert.NoError(t, err, "No Error Expected")
+}
+
+func TestGetDataFromFDB(t *testing.T) {
+	Fastcache.Purge()
+	EnableSecurity([]byte("MKCLSecurity$#@!"), "AAAAAAAAAAAAAAAA")
+	_, err := getDataFromFDB("../../testingdata/users_enc1.json")
+	DisableSecurity()
+	assert.NoError(t, err, "No Error Expected")
+}
+
+func Test1GetDataFromFDB(t *testing.T) {
+	Fastcache.Purge()
+	EnableSecurity([]byte("MKCLSecurity$#@!"), "AAAAAAAAAAAAAAAA")
+	errormdl.IsTestingNegetiveCaseOn1 = true
+	_, err := getDataFromFDB("../../testingdata/users_enc1.json")
+	errormdl.IsTestingNegetiveCaseOn1 = false
+	DisableSecurity()
+	assert.Error(t, err, "Error is Expected")
+}
+
+func Test2GetDataFromFDB(t *testing.T) {
+	Fastcache.Purge()
+	EnableSecurity([]byte("MKCLSecurity$#@!"), "AAAAAAAAAAAAAAAA")
+	errormdl.IsTestingNegetiveCaseOn2 = true
+	_, err := getDataFromFDB("../../testingdata/users_enc1.json")
+	errormdl.IsTestingNegetiveCaseOn2 = false
+	DisableSecurity()
+	assert.Error(t, err, "Error is Expected")
+}
+
+func Test3GetDataFromFDB(t *testing.T) {
+	Fastcache.Purge()
+	EnableSecurity([]byte("MKCLSecurity$#@!"), "AAAAAAAAAAAAAAAA")
+	errormdl.IsTestingNegetiveCaseOn3 = true
+	_, err := getDataFromFDB("../../testingdata/users_enc1.json")
+	errormdl.IsTestingNegetiveCaseOn3 = false
+	DisableSecurity()
+	assert.Error(t, err, "Error is Expected")
+}

routebuildermdl/responseHanldermdl.go

+package routebuildermdl
+
+import (
+	"time"
+
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/cachemdl"
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/utiliymdl/guidmdl"
+)
+
+//  Repose Header setting
+
+var responseHeaders cachemdl.FastCacheHelper
+
+func init() {
+	// TODO: Take all configurations from config module
+	responseHeaders.Setup(10, time.Minute*10, time.Minute*10)
+}
+
+// ResponseHeaders this is struct for Response headers
+type ResponseHeaders struct {
+	ServiceName string
+	HeaderID    string           `json:"headerId"`
+	LCache      bool             `json:"lCache"`
+	Methods     []responseMethod `json:"methods"`
+}
+
+type responseMethod struct {
+	MethodName string      `json:"methodName"`
+	Data       interface{} `json:"data"`
+}
+
+type responseData struct {
+	Result         interface{} `json:"result"`
+	Error          string      `json:"error"`
+	ResponseHeader interface{} `json:"reponseHeader"`
+}
+
+// CreateResponseHeader create an instance of response header for service
+func CreateResponseHeader(serviceName string) *ResponseHeaders {
+
+	lCacheflag := false
+	responseHeader, ok := responseHeaders.Get(serviceName)
+	if ok {
+		lCacheflag = responseHeader.(ResponseHeaders).LCache
+		// TODO: Delete functionality
+		// responseHeaders.Delete(serviceName)
+	}
+	rh := &ResponseHeaders{}
+	rh.ServiceName = serviceName
+	rh.LCache = lCacheflag
+	rh.HeaderID = guidmdl.GetGUID()
+	return rh
+}
+
+// EnableReponseCache cache this response in local storge
+func (rh *ResponseHeaders) EnableReponseCache() *ResponseHeaders {
+	rh.LCache = true
+	return rh
+}
+
+// DisableReponseCache cache this response in local storge
+func (rh *ResponseHeaders) DisableReponseCache() *ResponseHeaders {
+	rh.LCache = false
+	return rh
+}
+
+// AddMethod add method and data in response
+func (rh *ResponseHeaders) AddMethod(name string, data interface{}) *ResponseHeaders {
+	rh.Methods = append(rh.Methods, responseMethod{MethodName: name, Data: data})
+	return rh
+}
+
+// SetResponseHeader set response headers in cache
+func (rh *ResponseHeaders) SetResponseHeader() {
+	responseHeaders.Set(rh.ServiceName, *rh)
+}
+
+// GetResponseHeader return response header object
+func GetResponseHeader(serviceName string) (interface{}, bool) {
+	return responseHeaders.Get(serviceName)
+}

routebuildermdl/routebuildermdl.go

+package routebuildermdl
+
+import (
+	"errors"
+	"io/ioutil"
+	"mime/multipart"
+	"net/http"
+	"strings"
+
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/loggermdl"
+
+	"github.com/gin-gonic/gin"
+)
+
+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
+	} else {
+		loggermdl.LogError("Service not Found")
+	}
+	return rd
+}
+
+func isMultipartRequest(header string) bool {
+	return strings.HasPrefix(header, "multipart/form-data")
+}
+func isFormRequest(header string) bool {
+	return strings.HasPrefix(header, "application/x-www-form-urlencoded")
+
+}
+
+func executeService(name string, data []byte, isForm bool, formData *multipart.Form, isRestricted bool) (interface{}, error) {
+	var service interface{}
+	var found bool
+	if isRestricted {
+		service, found = restrictedServices.Get(name)
+	} else {
+		service, found = openServices.Get(name)
+	}
+	loggermdl.LogInfo(service, found, name, isRestricted)
+	if !found {
+		return nil, errors.New("Service Not Found: " + name)
+	}
+
+	if isForm {
+		serviceCache := service.(ServiceCache)
+		return serviceCache.FormService(formData)
+	}
+	serviceCache := service.(ServiceCache)
+	if serviceCache.IsFormService {
+		return nil, errors.New("Form_Header_Missing")
+	}
+	if serviceCache.IsMasterService {
+		return serviceCache.MasterService.Run(nil)
+	}
+	return serviceCache.Service(data)
+}
+
+func commonHandler(c *gin.Context, isRestricted 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 multiPartError != nil {
+			responseDataObj.Error = multiPartError.Error()
+			c.JSON(http.StatusExpectationFailed, responseDataObj)
+			return
+		}
+		result, err := executeService(service, nil, true, form, isRestricted)
+		if err != nil {
+			responseDataObj.Error = err.Error()
+			c.JSON(http.StatusExpectationFailed, responseDataObj)
+			return
+		}
+		responseDataObj.Result = result
+		c.JSON(http.StatusOK, responseDataObj)
+		return
+	}
+	reqBody, readError := ioutil.ReadAll(c.Request.Body)
+	if readError != nil {
+		responseDataObj.Error = readError.Error()
+		c.JSON(http.StatusExpectationFailed, responseDataObj)
+		return
+	}
+	result, err := executeService(service, reqBody, false, nil, isRestricted)
+	if err != nil {
+		responseDataObj.Error = err.Error()
+		c.JSON(http.StatusExpectationFailed, responseDataObj)
+		return
+	}
+	responseDataObj.Result = result
+	c.JSON(http.StatusOK, responseDataObj)
+	return
+
+}
+
+func OpenHandler(c *gin.Context) {
+	commonHandler(c, false)
+}
+
+func RestrictedHandler(c *gin.Context) {
+	commonHandler(c, true)
+}
+
+func RoleBasedHandler(c *gin.Context) {
+	commonHandler(c, true)
+}

routebuildermdl/serviceCachemdl.go

+package routebuildermdl
+
+import (
+	"mime/multipart"
+	"time"
+
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/cachemdl"
+	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/servicebuildermdl"
+)
+
+var restrictedServices cachemdl.FastCacheHelper
+var openServices cachemdl.FastCacheHelper
+
+func init() {
+	// TODO: Take configuration from config file
+	restrictedServices.Setup(10, time.Second*600, time.Second*600)
+	openServices.Setup(10, time.Second*600, time.Second*600)
+}
+
+// ServiceCache ServiceCache object
+type ServiceCache struct {
+	Service         func([]byte) (interface{}, error)
+	FormService     func(*multipart.Form) (interface{}, error)
+	MasterService   *servicebuildermdl.ServiceBuilder
+	IsMasterService bool
+	IsFormService   bool
+}
+
+func RegisterNormalService(serviceName string, servicePtr func([]byte) (interface{}, error), isRestricted bool) {
+	service := ServiceCache{
+		Service: servicePtr,
+	}
+	if isRestricted {
+		restrictedServices.Set(serviceName, service)
+	} else {
+		openServices.Set(serviceName, service)
+	}
+}
+
+func RegisterFormBasedService(serviceName string, servicePtr func(*multipart.Form) (interface{}, error), isRestricted bool) {
+	service := ServiceCache{
+		FormService:   servicePtr,
+		IsFormService: true,
+	}
+	if isRestricted {
+		restrictedServices.Set(serviceName, service)
+	} else {
+		openServices.Set(serviceName, service)
+	}
+}
+
+func RegisterMasterService(serviceName string, servicePtr *servicebuildermdl.ServiceBuilder, isRestricted bool) {
+	service := ServiceCache{
+		MasterService:   servicePtr,
+		IsMasterService: true,
+	}
+	if isRestricted {
+		restrictedServices.Set(serviceName, service)
+	} else {
+		openServices.Set(serviceName, service)
+	}
+}

servicebuildermdl/servicebuildermdl.go

@@ -213,6 +213,10 @@ func (sb *ServiceBuilder) Run(fn FinalStepProcessOutput) (*interface{}, error) {
 		loggermdl.LogError(sb.ServiceError)
 		return nil, errormdl.CheckErr(sb.ServiceError)
 	}
+	_, ok := sb.businessLogicHolder.localServiceData["finaldata"]
+	if ok {
+		return sb.businessLogicHolder.GetFinalData(), nil
+	}
 	for _, step := range sb.steps {
 		//Load Data
 		if step.processDataFunc != nil {