Commit 99f70670 authored by Roshan Patil's avatar Roshan Patil
Browse files

route builder module

parent 86b09133
Branches
Tags
2 merge requests!23Devbranch to Master,!21route builder module
Showing with 311 additions and 0 deletions
......@@ -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")
}
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)
}
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)
}
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)
}
}
......@@ -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 {
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment