serviceCachemdl.go

package routebuildermdl

import (
	"bytes"
	"fmt"
	"mime/multipart"
	"strings"
	"time"

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

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

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/cachemdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/servicebuildermdl"
)

const (
	// EXPORT :- js export
	EXPORT = "export"
	// CONSTT :- js const
	CONSTT     = "const"
	open       = "O_"
	restricted = "R_"
	acl        = "C_"
)

var restrictedServices cachemdl.FastCacheHelper
var roleBasedServices cachemdl.FastCacheHelper
var openServices cachemdl.FastCacheHelper

func init() {
	restrictedServices.Setup(10, time.Second*600, time.Second*600)
	openServices.Setup(10, time.Second*600, time.Second*600)
	roleBasedServices.Setup(10, time.Second*600, time.Second*600)
	RegisterNormalService("CreateServiceJS", createServiceJS, false, false)
}

// ServiceCache ServiceCache object
type ServiceCache struct {
	Service         func([]byte) (interface{}, error)
	FormService     func(*multipart.Form) (interface{}, error)
	MasterService   *servicebuildermdl.ServiceBuilder
	IsMasterService bool
	IsFormService   bool
}

// RegisterNormalService is for transactional services
func RegisterNormalService(serviceName string, servicePtr func([]byte) (interface{}, error), isRestricted, isRoleBased bool) {
	service := ServiceCache{
		Service: servicePtr,
	}
	commonServiceRegistration(serviceName, service, isRestricted, isRoleBased)
}

// RegisterFormBasedService if for multipart form based services
func RegisterFormBasedService(serviceName string, servicePtr func(*multipart.Form) (interface{}, error), isRestricted, isRoleBased bool) {
	service := ServiceCache{
		FormService:   servicePtr,
		IsFormService: true,
	}
	commonServiceRegistration(serviceName, service, isRestricted, isRoleBased)
}

// RegisterMasterService is for getting master type of file
func RegisterMasterService(serviceName string, servicePtr *servicebuildermdl.ServiceBuilder, isRestricted, isRoleBased bool) {
	service := ServiceCache{
		MasterService:   servicePtr,
		IsMasterService: true,
	}
	commonServiceRegistration(serviceName, service, isRestricted, isRoleBased)
}

func commonServiceRegistration(serviceName string, service ServiceCache, isRestricted, isRoleBased bool) {
	if isRestricted {
		if isRoleBased {
			roleBasedServices.SetNoExpiration(serviceName, service)
		} else {
			restrictedServices.SetNoExpiration(serviceName, service)
		}
	} else {
		openServices.SetNoExpiration(serviceName, service)
	}
}

func createServiceJS(data []byte) (interface{}, error) {
	buf := new(bytes.Buffer)

	for k := range openServices.FastCache.Items() {
		srv := EXPORT + " " + CONSTT + " " + open + strings.ToUpper(k) + " = 'O." + k + "'"
		buf.WriteString(fmt.Sprintln(srv))
	}
	for k := range restrictedServices.FastCache.Items() {
		srv := EXPORT + " " + CONSTT + " " + restricted + strings.ToUpper(k) + " = 'R." + k + "'"
		buf.WriteString(fmt.Sprintln(srv))
	}
	for k := range roleBasedServices.FastCache.Items() {
		srv := EXPORT + " " + CONSTT + " " + acl + strings.ToUpper(k) + " = 'C." + k + "'"
		buf.WriteString(fmt.Sprintln(srv))
	}

	saveError := filemdl.GetInstance().Save("./services.js", buf.Bytes(), true, false)
	if errormdl.CheckErr(saveError) != nil {
		return nil, errormdl.CheckErr(saveError)
	}
	return "success", nil
}