apier compiling and passing tests

2026-02-11 18:16:24 +05:00 · 2015-06-05 16:00:07 +03:00
parent 29f51cd478
commit dd7fe52ce6
18 changed files with 209 additions and 106 deletions
--- a/apier/v1/accounts.go
+++ b/apier/v1/accounts.go
@@ -46,7 +46,7 @@ func (self *ApierV1) GetAccountActionPlan(attrs AttrAcntAction, reply *[]*Accoun
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
 	accountATs := make([]*AccountActionTiming, 0)
-	allATs, err := self.AccountDb.GetAllActionTimings()
+	allATs, err := self.AccountDb.GetAllActionPlans()
 	if err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
@@ -81,14 +81,14 @@ func (self *ApierV1) RemActionTiming(attrs AttrRemActionTiming, reply *string) e
 		}
 	}
 	_, err := engine.AccLock.Guard(func() (interface{}, error) {
-		ats, err := self.AccountDb.GetActionTimings(attrs.ActionPlanId)
+		ats, err := self.AccountDb.GetActionPlans(attrs.ActionPlanId)
 		if err != nil {
 			return 0, err
 		} else if len(ats) == 0 {
 			return 0, errors.New(utils.ERR_NOT_FOUND)
 		}
-		ats = engine.RemActionTiming(ats, attrs.ActionTimingId, utils.AccountKey(attrs.Tenant, attrs.Account, attrs.Direction))
-		if err := self.AccountDb.SetActionTimings(attrs.ActionPlanId, ats); err != nil {
+		ats = engine.RemActionPlan(ats, attrs.ActionTimingId, utils.AccountKey(attrs.Tenant, attrs.Account, attrs.Direction))
+		if err := self.AccountDb.SetActionPlans(attrs.ActionPlanId, ats); err != nil {
 			return 0, err
 		}
 		return 0, nil
@@ -97,7 +97,7 @@ func (self *ApierV1) RemActionTiming(attrs AttrRemActionTiming, reply *string) e
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	if attrs.ReloadScheduler && self.Sched != nil {
-		self.Sched.LoadActionTimings(self.AccountDb)
+		self.Sched.LoadActionPlans(self.AccountDb)
 		self.Sched.Restart()
 	}
 	*reply = OK
@@ -165,7 +165,7 @@ func (self *ApierV1) SetAccount(attr utils.AttrSetAccount, reply *string) error
 	}
 	balanceId := utils.AccountKey(attr.Tenant, attr.Account, attr.Direction)
 	var ub *engine.Account
-	var ats engine.ActionPlan
+	var ats engine.ActionPlans
 	_, err := engine.AccLock.Guard(func() (interface{}, error) {
 		if bal, _ := self.AccountDb.GetAccount(balanceId); bal != nil {
 			ub = bal
@@ -178,7 +178,7 @@ func (self *ApierV1) SetAccount(attr utils.AttrSetAccount, reply *string) error

 		if len(attr.ActionPlanId) != 0 {
 			var err error
-			ats, err = self.AccountDb.GetActionTimings(attr.ActionPlanId)
+			ats, err = self.AccountDb.GetActionPlans(attr.ActionPlanId)
 			if err != nil {
 				return 0, err
 			}
@@ -197,7 +197,7 @@ func (self *ApierV1) SetAccount(attr utils.AttrSetAccount, reply *string) error
 	}
 	if len(ats) != 0 {
 		_, err := engine.AccLock.Guard(func() (interface{}, error) { // ToDo: Try locking it above on read somehow
-			if err := self.AccountDb.SetActionTimings(attr.ActionPlanId, ats); err != nil {
+			if err := self.AccountDb.SetActionPlans(attr.ActionPlanId, ats); err != nil {
 				return 0, err
 			}
 			return 0, nil
@@ -206,7 +206,7 @@ func (self *ApierV1) SetAccount(attr utils.AttrSetAccount, reply *string) error
 			return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 		}
 		if self.Sched != nil {
-			self.Sched.LoadActionTimings(self.AccountDb)
+			self.Sched.LoadActionPlans(self.AccountDb)
 			self.Sched.Restart()
 		}
 	}
--- a/apier/v1/apier.go
+++ b/apier/v1/apier.go
@@ -128,7 +128,7 @@ func (self *ApierV1) AddBalance(attr *AttrAddBalance, reply *string) error {
 			return err
 		}
 	}
-	at := &engine.ActionTiming{
+	at := &engine.ActionPlan{
 		AccountIds: []string{tag},
 	}
 	if attr.Direction == "" {
@@ -167,7 +167,7 @@ func (self *ApierV1) AddBalance(attr *AttrAddBalance, reply *string) error {

 func (self *ApierV1) ExecuteAction(attr *utils.AttrExecuteAction, reply *string) error {
 	tag := fmt.Sprintf("%s:%s:%s", attr.Direction, attr.Tenant, attr.Account)
-	at := &engine.ActionTiming{
+	at := &engine.ActionPlan{
 		AccountIds: []string{tag},
 		ActionsId:  attr.ActionsId,
 	}
@@ -214,7 +214,8 @@ func (self *ApierV1) LoadDerivedChargers(attrs utils.TPDerivedChargers, reply *s
 		return fmt.Errorf("%s:%s", utils.ERR_MANDATORY_IE_MISSING, "TPid")
 	}
 	dbReader := engine.NewTpReader(self.RatingDb, self.AccountDb, self.StorDb, attrs.TPid)
-	if err := dbReader.LoadDerivedChargersFiltered(&attrs, true); err != nil {
+	dc := engine.APItoModelDerivedCharger(&attrs)
+	if err := dbReader.LoadDerivedChargersFiltered(&dc[0], true); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	//Automatic cache of the newly inserted rating plan
@@ -265,7 +266,8 @@ func (self *ApierV1) LoadRatingProfile(attrs utils.TPRatingProfile, reply *strin
 		return fmt.Errorf("%s:%s", utils.ERR_MANDATORY_IE_MISSING, "TPid")
 	}
 	dbReader := engine.NewTpReader(self.RatingDb, self.AccountDb, self.StorDb, attrs.TPid)
-	if err := dbReader.LoadRatingProfilesFiltered(&attrs); err != nil {
+	rp := engine.APItoModelRatingProfile(&attrs)
+	if err := dbReader.LoadRatingProfilesFiltered(&rp[0]); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	//Automatic cache of the newly inserted rating profile
@@ -411,7 +413,7 @@ func (self *ApierV1) LoadTariffPlanFromStorDb(attrs AttrLoadTpFromStorDb, reply
 	aps, _ := dbReader.GetLoadedIds(engine.ACTION_TIMING_PREFIX)
 	if len(aps) != 0 && self.Sched != nil {
 		engine.Logger.Info("ApierV1.LoadTariffPlanFromStorDb, reloading scheduler.")
-		self.Sched.LoadActionTimings(self.AccountDb)
+		self.Sched.LoadActionPlans(self.AccountDb)
 		self.Sched.Restart()
 	}
 	cstKeys, _ := dbReader.GetLoadedIds(engine.CDR_STATS_PREFIX)
@@ -598,13 +600,13 @@ func (self *ApierV1) GetActions(actsId string, reply *[]*utils.TPAction) error {
 }

 type AttrSetActionPlan struct {
-	Id              string             // Profile id
-	ActionPlan      []*ApiActionTiming // Set of actions this Actions profile will perform
-	Overwrite       bool               // If previously defined, will be overwritten
-	ReloadScheduler bool               // Enables automatic reload of the scheduler (eg: useful when adding a single action timing)
+	Id              string           // Profile id
+	ActionPlan      []*ApiActionPlan // Set of actions this Actions profile will perform
+	Overwrite       bool             // If previously defined, will be overwritten
+	ReloadScheduler bool             // Enables automatic reload of the scheduler (eg: useful when adding a single action timing)
 }

-type ApiActionTiming struct {
+type ApiActionPlan struct {
 	ActionsId string  // Actions id
 	Years     string  // semicolon separated list of years this timing is valid on, *any or empty supported
 	Months    string  // semicolon separated list of months this timing is valid on, *any or empty supported
@@ -631,7 +633,7 @@ func (self *ApierV1) SetActionPlan(attrs AttrSetActionPlan, reply *string) error
 			return errors.New(utils.ERR_EXISTS)
 		}
 	}
-	storeAtms := make(engine.ActionPlan, len(attrs.ActionPlan))
+	storeAtms := make(engine.ActionPlans, len(attrs.ActionPlan))
 	for idx, apiAtm := range attrs.ActionPlan {
 		if exists, err := self.AccountDb.HasData(engine.ACTION_PREFIX, apiAtm.ActionsId); err != nil {
 			return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
@@ -644,7 +646,7 @@ func (self *ApierV1) SetActionPlan(attrs AttrSetActionPlan, reply *string) error
 		timing.MonthDays.Parse(apiAtm.MonthDays, ";")
 		timing.WeekDays.Parse(apiAtm.WeekDays, ";")
 		timing.StartTime = apiAtm.Time
-		at := &engine.ActionTiming{
+		at := &engine.ActionPlan{
 			Uuid:      utils.GenUUID(),
 			Id:        attrs.Id,
 			Weight:    apiAtm.Weight,
@@ -653,14 +655,14 @@ func (self *ApierV1) SetActionPlan(attrs AttrSetActionPlan, reply *string) error
 		}
 		storeAtms[idx] = at
 	}
-	if err := self.AccountDb.SetActionTimings(attrs.Id, storeAtms); err != nil {
+	if err := self.AccountDb.SetActionPlans(attrs.Id, storeAtms); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	if attrs.ReloadScheduler {
 		if self.Sched == nil {
 			return errors.New("SCHEDULER_NOT_ENABLED")
 		}
-		self.Sched.LoadActionTimings(self.AccountDb)
+		self.Sched.LoadActionPlans(self.AccountDb)
 		self.Sched.Restart()
 	}
 	*reply = OK
@@ -807,7 +809,8 @@ func (self *ApierV1) LoadAccountActions(attrs utils.TPAccountActions, reply *str
 	}
 	dbReader := engine.NewTpReader(self.RatingDb, self.AccountDb, self.StorDb, attrs.TPid)
 	if _, err := engine.AccLock.Guard(func() (interface{}, error) {
-		if err := dbReader.LoadAccountActionsFiltered(&attrs); err != nil {
+		aas := engine.APItoModelAccountAction(&attrs)
+		if err := dbReader.LoadAccountActionsFiltered(aas); err != nil {
 			return 0, err
 		}
 		return 0, nil
@@ -820,7 +823,7 @@ func (self *ApierV1) LoadAccountActions(attrs utils.TPAccountActions, reply *str
 		return err
 	}
 	if self.Sched != nil {
-		self.Sched.LoadActionTimings(self.AccountDb)
+		self.Sched.LoadActionPlans(self.AccountDb)
 		self.Sched.Restart()
 	}
 	*reply = OK
@@ -831,7 +834,7 @@ func (self *ApierV1) ReloadScheduler(input string, reply *string) error {
 	if self.Sched == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
 	}
-	self.Sched.LoadActionTimings(self.AccountDb)
+	self.Sched.LoadActionPlans(self.AccountDb)
 	self.Sched.Restart()
 	*reply = OK
 	return nil
@@ -1059,7 +1062,7 @@ func (self *ApierV1) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder,
 	}
 	if len(aps) != 0 && self.Sched != nil {
 		engine.Logger.Info("ApierV1.LoadTariffPlanFromFolder, reloading scheduler.")
-		self.Sched.LoadActionTimings(self.AccountDb)
+		self.Sched.LoadActionPlans(self.AccountDb)
 		self.Sched.Restart()
 	}
 	cstKeys, _ := loader.GetLoadedIds(engine.CDR_STATS_PREFIX)
--- a/apier/v1/apier_local_test.go
+++ b/apier/v1/apier_local_test.go
@@ -1008,8 +1008,8 @@ func TestApierSetActionPlan(t *testing.T) {
 	if !*testLocal {
 		return
 	}
-	atm1 := &ApiActionTiming{ActionsId: "ACTS_1", MonthDays: "1", Time: "00:00:00", Weight: 20.0}
-	atms1 := &AttrSetActionPlan{Id: "ATMS_1", ActionPlan: []*ApiActionTiming{atm1}}
+	atm1 := &ApiActionPlan{ActionsId: "ACTS_1", MonthDays: "1", Time: "00:00:00", Weight: 20.0}
+	atms1 := &AttrSetActionPlan{Id: "ATMS_1", ActionPlan: []*ApiActionPlan{atm1}}
 	reply1 := ""
 	if err := rater.Call("ApierV1.SetActionPlan", atms1, &reply1); err != nil {
 		t.Error("Got error on ApierV1.SetActionPlan: ", err.Error())
--- a/apier/v1/tpaccountactions.go
+++ b/apier/v1/tpaccountactions.go
@@ -32,7 +32,8 @@ func (self *ApierV1) SetTPAccountActions(attrs utils.TPAccountActions, reply *st
 		[]string{"TPid", "LoadId", "Tenant", "Account", "Direction", "ActionPlanId", "ActionTriggersId"}); len(missing) != 0 {
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.SetTPAccountActions(attrs.TPid, map[string]*utils.TPAccountActions{attrs.KeyId(): &attrs}); err != nil {
+	aas := engine.APItoModelAccountAction(&attrs)
+	if err := self.StorDb.SetTpAccountActions([]engine.TpAccountAction{*aas}); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -53,16 +54,22 @@ func (self *ApierV1) GetTPAccountActionsByLoadId(attrs utils.TPAccountActions, r
 	if missing := utils.MissingStructFields(&attrs, mndtryFlds); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if aa, err := self.StorDb.GetTpAccountActions(&attrs); err != nil {
+	aas := engine.APItoModelAccountAction(&attrs)
+	if aa, err := self.StorDb.GetTpAccountActions(aas); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if len(aa) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
+
+		tpAa, err := engine.TpAccountActions(aa).GetAccountActions()
+		if err != nil {
+			return err
+		}
 		var acts []*utils.TPAccountActions
 		if len(attrs.Account) != 0 {
-			acts = []*utils.TPAccountActions{aa[attrs.KeyId()]}
+			acts = []*utils.TPAccountActions{tpAa[attrs.KeyId()]}
 		} else {
-			for _, actLst := range aa {
+			for _, actLst := range tpAa {
 				acts = append(acts, actLst)
 			}
 		}
@@ -85,12 +92,17 @@ func (self *ApierV1) GetTPAccountActions(attrs AttrGetTPAccountActions, reply *u
 	if err := tmpAa.SetAccountActionsId(attrs.AccountActionsId); err != nil {
 		return err
 	}
-	if aas, err := self.StorDb.GetTpAccountActions(tmpAa); err != nil {
+	tmpAaa := engine.APItoModelAccountAction(tmpAa)
+	if aas, err := self.StorDb.GetTpAccountActions(tmpAaa); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if len(aas) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		aa := aas[tmpAa.KeyId()]
+		tpAaa, err := engine.TpAccountActions(aas).GetAccountActions()
+		if err != nil {
+			return err
+		}
+		aa := tpAaa[tmpAa.KeyId()]
 		tpdc := utils.TPAccountActions{
 			TPid:             attrs.TPid,
 			ActionPlanId:     aa.ActionPlanId,
@@ -114,7 +126,7 @@ func (self *ApierV1) GetTPAccountActionLoadIds(attrs AttrGetTPAccountActionIds,
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_ACCOUNT_ACTIONS, utils.TPDistinctIds{"loadid"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_ACCOUNT_ACTIONS, utils.TPDistinctIds{"loadid"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -129,7 +141,7 @@ func (self *ApierV1) GetTPAccountActionIds(attrs AttrGetTPAccountActionIds, repl
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_ACCOUNT_ACTIONS, utils.TPDistinctIds{"loadid", "direction", "tenant", "account"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_ACCOUNT_ACTIONS, utils.TPDistinctIds{"loadid", "direction", "tenant", "account"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -148,7 +160,7 @@ func (self *ApierV1) RemTPAccountActions(attrs AttrGetTPAccountActions, reply *s
 	if err := aa.SetAccountActionId(attrs.AccountActionsId); err != nil {
 		return err
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_ACCOUNT_ACTIONS, aa.Tpid, aa.Loadid, aa.Direction, aa.Tenant, aa.Account); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_ACCOUNT_ACTIONS, aa.Tpid, aa.Loadid, aa.Direction, aa.Tenant, aa.Account); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpactions.go
+++ b/apier/v1/tpactions.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -39,7 +40,8 @@ func (self *ApierV1) SetTPActions(attrs utils.TPActions, reply *string) error {
 			return fmt.Errorf("%s:Action:%s:%v", utils.ERR_MANDATORY_IE_MISSING, action.Identifier, missing)
 		}
 	}
-	if err := self.StorDb.SetTPActions(attrs.TPid, map[string][]*utils.TPAction{attrs.ActionsId: attrs.Actions}); err != nil {
+	as := engine.APItoModelAction(&attrs)
+	if err := self.StorDb.SetTpActions(as); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -61,7 +63,11 @@ func (self *ApierV1) GetTPActions(attrs AttrGetTPActions, reply *utils.TPActions
 	} else if len(acts) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		*reply = utils.TPActions{TPid: attrs.TPid, ActionsId: attrs.ActionsId, Actions: acts[attrs.ActionsId]}
+		as, err := engine.TpActions(acts).GetActions()
+		if err != nil {
+
+		}
+		*reply = utils.TPActions{TPid: attrs.TPid, ActionsId: attrs.ActionsId, Actions: as[attrs.ActionsId]}
 	}
 	return nil
 }
@@ -76,7 +82,7 @@ func (self *ApierV1) GetTPActionIds(attrs AttrGetTPActionIds, reply *[]string) e
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_ACTIONS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_ACTIONS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -91,7 +97,7 @@ func (self *ApierV1) RemTPActions(attrs AttrGetTPActions, reply *string) error {
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "ActionsId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_ACTIONS, attrs.TPid, attrs.ActionsId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_ACTIONS, attrs.TPid, attrs.ActionsId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpactiontimings.go
+++ b/apier/v1/tpactiontimings.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -36,7 +37,8 @@ func (self *ApierV1) SetTPActionPlan(attrs utils.TPActionPlan, reply *string) er
 			return fmt.Errorf("%s:Action:%s:%v", utils.ERR_MANDATORY_IE_MISSING, at.ActionsId, missing)
 		}
 	}
-	if err := self.StorDb.SetTPActionTimings(attrs.TPid, map[string][]*utils.TPActionTiming{attrs.Id: attrs.ActionPlan}); err != nil {
+	ap := engine.APItoModelActionPlan(&attrs)
+	if err := self.StorDb.SetTpActionPlans(ap); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -45,7 +47,7 @@ func (self *ApierV1) SetTPActionPlan(attrs utils.TPActionPlan, reply *string) er

 type AttrGetTPActionPlan struct {
 	TPid string // Tariff plan id
-	Id   string // ActionTimings id
+	Id   string // ActionPlans id
 }

 // Queries specific ActionPlan profile on tariff plan
@@ -53,15 +55,19 @@ func (self *ApierV1) GetTPActionPlan(attrs AttrGetTPActionPlan, reply *utils.TPA
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "Id"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ats, err := self.StorDb.GetTPActionTimings(attrs.TPid, attrs.Id); err != nil {
+	if ats, err := self.StorDb.GetTpActionPlans(attrs.TPid, attrs.Id); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if len(ats) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else { // Got the data we need, convert it
+		aps, err := engine.TpActionPlans(ats).GetActionPlans()
+		if err != nil {
+			return err
+		}
 		atRply := &utils.TPActionPlan{
 			TPid:       attrs.TPid,
 			Id:         attrs.Id,
-			ActionPlan: ats[attrs.Id],
+			ActionPlan: aps[attrs.Id],
 		}
 		*reply = *atRply
 	}
@@ -78,7 +84,7 @@ func (self *ApierV1) GetTPActionPlanIds(attrs AttrGetTPActionPlanIds, reply *[]s
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_ACTION_PLANS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_ACTION_PLANS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -93,7 +99,7 @@ func (self *ApierV1) RemTPActionPlan(attrs AttrGetTPActionPlan, reply *string) e
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "Id"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_ACTION_PLANS, attrs.TPid, attrs.Id); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_ACTION_PLANS, attrs.TPid, attrs.Id); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpactiontriggers.go
+++ b/apier/v1/tpactiontriggers.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -31,10 +32,9 @@ func (self *ApierV1) SetTPActionTriggers(attrs utils.TPActionTriggers, reply *st
 		[]string{"TPid", "ActionTriggersId"}); len(missing) != 0 {
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	ats := map[string][]*utils.TPActionTrigger{
-		attrs.ActionTriggersId: attrs.ActionTriggers}

-	if err := self.StorDb.SetTPActionTriggers(attrs.TPid, ats); err != nil {
+	ats := engine.APItoModelActionTrigger(&attrs)
+	if err := self.StorDb.SetTpActionTriggers(ats); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -51,11 +51,15 @@ func (self *ApierV1) GetTPActionTriggers(attrs AttrGetTPActionTriggers, reply *u
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "ActionTriggersId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if atsMap, err := self.StorDb.GetTpActionTriggers(attrs.TPid, attrs.ActionTriggersId); err != nil {
+	if ats, err := self.StorDb.GetTpActionTriggers(attrs.TPid, attrs.ActionTriggersId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
-	} else if len(atsMap) == 0 {
+	} else if len(ats) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
+		atsMap, err := engine.TpActionTriggers(ats).GetActionTriggers()
+		if err != nil {
+			return err
+		}
 		atRply := &utils.TPActionTriggers{
 			TPid:             attrs.TPid,
 			ActionTriggersId: attrs.ActionTriggersId,
@@ -76,7 +80,7 @@ func (self *ApierV1) GetTPActionTriggerIds(attrs AttrGetTPActionTriggerIds, repl
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_ACTION_TRIGGERS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_ACTION_TRIGGERS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -91,7 +95,7 @@ func (self *ApierV1) RemTPActionTriggers(attrs AttrGetTPActionTriggers, reply *s
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "ActionTriggersId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_ACTION_TRIGGERS, attrs.TPid, attrs.ActionTriggersId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_ACTION_TRIGGERS, attrs.TPid, attrs.ActionTriggersId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpcdrstats.go
+++ b/apier/v1/tpcdrstats.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -39,7 +40,8 @@ func (self *ApierV1) SetTPCdrStats(attrs utils.TPCdrStats, reply *string) error
 			return fmt.Errorf("%s:CdrStat:%s:%v", utils.ERR_MANDATORY_IE_MISSING, action.Identifier, missing)
 		}
 	}*/
-	if err := self.StorDb.SetTPCdrStats(attrs.TPid, map[string][]*utils.TPCdrStat{attrs.CdrStatsId: attrs.CdrStats}); err != nil {
+	cs := engine.APItoModelCdrStat(&attrs)
+	if err := self.StorDb.SetTpCdrStats(cs); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -61,7 +63,11 @@ func (self *ApierV1) GetTPCdrStats(attrs AttrGetTPCdrStats, reply *utils.TPCdrSt
 	} else if len(sgs) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		*reply = utils.TPCdrStats{TPid: attrs.TPid, CdrStatsId: attrs.CdrStatsId, CdrStats: sgs[attrs.CdrStatsId]}
+		csMap, err := engine.TpCdrStats(sgs).GetCdrStats()
+		if err != nil {
+			return err
+		}
+		*reply = utils.TPCdrStats{TPid: attrs.TPid, CdrStatsId: attrs.CdrStatsId, CdrStats: csMap[attrs.CdrStatsId]}
 	}
 	return nil
 }
@@ -76,7 +82,7 @@ func (self *ApierV1) GetTPCdrStatsIds(attrs AttrGetTPCdrStatIds, reply *[]string
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_CDR_STATS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_CDR_STATS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -91,7 +97,7 @@ func (self *ApierV1) RemTPCdrStats(attrs AttrGetTPCdrStats, reply *string) error
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "CdrStatsId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_SHARED_GROUPS, attrs.TPid, attrs.CdrStatsId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_SHARED_GROUPS, attrs.TPid, attrs.CdrStatsId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpderivedcharges.go
+++ b/apier/v1/tpderivedcharges.go
@@ -40,9 +40,8 @@ func (self *ApierV1) SetTPDerivedChargers(attrs utils.TPDerivedChargers, reply *
 			return fmt.Errorf("%s:DerivedCharge:%s:%v", utils.ERR_MANDATORY_IE_MISSING, action.Identifier, missing)
 		}
 	}*/
-	if err := self.StorDb.SetTPDerivedChargers(attrs.TPid, map[string][]*utils.TPDerivedCharger{
-		attrs.GetDerivedChargesId(): attrs.DerivedChargers,
-	}); err != nil {
+	dc := engine.APItoModelDerivedCharger(&attrs)
+	if err := self.StorDb.SetTpDerivedChargers(dc); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -63,12 +62,17 @@ func (self *ApierV1) GetTPDerivedChargers(attrs AttrGetTPDerivedChargers, reply
 	if err := tmpDc.SetDerivedChargersId(attrs.DerivedChargersId); err != nil {
 		return err
 	}
-	if sgs, err := self.StorDb.GetTpDerivedChargers(tmpDc); err != nil {
+	dcs := engine.APItoModelDerivedCharger(tmpDc)
+	if sgs, err := self.StorDb.GetTpDerivedChargers(&dcs[0]); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if len(sgs) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		*reply = *sgs[attrs.DerivedChargersId]
+		dcsMap, err := engine.TpDerivedChargers(dcs).GetDerivedChargers()
+		if err != nil {
+			return err
+		}
+		*reply = *dcsMap[attrs.DerivedChargersId]
 	}
 	return nil
 }
@@ -83,7 +87,7 @@ func (self *ApierV1) GetTPDerivedChargerIds(attrs AttrGetTPDerivedChargeIds, rep
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_DERIVED_CHARGERS, utils.TPDistinctIds{"loadid", "direction", "tenant", "category", "account", "subject"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_DERIVED_CHARGERS, utils.TPDistinctIds{"loadid", "direction", "tenant", "category", "account", "subject"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -102,7 +106,7 @@ func (self *ApierV1) RemTPDerivedChargers(attrs AttrGetTPDerivedChargers, reply
 	if err := tmpDc.SetDerivedChargersId(attrs.DerivedChargersId); err != nil {
 		return err
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_DERIVED_CHARGERS, attrs.TPid, tmpDc.Loadid, tmpDc.Direction, tmpDc.Tenant, tmpDc.Category, tmpDc.Account, tmpDc.Subject); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_DERIVED_CHARGERS, attrs.TPid, tmpDc.Loadid, tmpDc.Direction, tmpDc.Tenant, tmpDc.Category, tmpDc.Account, tmpDc.Subject); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpdestinationrates.go
+++ b/apier/v1/tpdestinationrates.go
@@ -24,6 +24,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -32,7 +33,8 @@ func (self *ApierV1) SetTPDestinationRate(attrs utils.TPDestinationRate, reply *
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "DestinationRateId", "DestinationRates"}); len(missing) != 0 {
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.SetTPDestinationRates(attrs.TPid, map[string][]*utils.DestinationRate{attrs.DestinationRateId: attrs.DestinationRates}); err != nil {
+	drs := engine.APItoModelDestinationRate(&attrs)
+	if err := self.StorDb.SetTpDestinationRates(drs); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -55,7 +57,11 @@ func (self *ApierV1) GetTPDestinationRate(attrs AttrGetTPDestinationRate, reply
 	} else if len(drs) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		*reply = *drs[attrs.DestinationRateId]
+		drsMap, err := engine.TpDestinationRates(drs).GetDestinationRates()
+		if err != nil {
+			return err
+		}
+		*reply = *drsMap[attrs.DestinationRateId]
 	}
 	return nil
 }
@@ -70,7 +76,7 @@ func (self *ApierV1) GetTPDestinationRateIds(attrs AttrGetTPRateIds, reply *[]st
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_DESTINATION_RATES, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_DESTINATION_RATES, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -85,7 +91,7 @@ func (self *ApierV1) RemTPDestinationRate(attrs AttrGetTPDestinationRate, reply
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "DestinationRateId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_DESTINATION_RATES, attrs.TPid, attrs.DestinationRateId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_DESTINATION_RATES, attrs.TPid, attrs.DestinationRateId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpdestinations.go
+++ b/apier/v1/tpdestinations.go
@@ -31,7 +31,8 @@ func (self *ApierV1) SetTPDestination(attrs utils.TPDestination, reply *string)
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "DestinationId", "Prefixes"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.SetTPDestination(attrs.TPid, &engine.Destination{Id: attrs.DestinationId, Prefixes: attrs.Prefixes}); err != nil {
+	ds := engine.APItoModelDestination(&attrs)
+	if err := self.StorDb.SetTpDestinations(ds); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -54,7 +55,10 @@ func (self *ApierV1) GetTPDestination(attrs AttrGetTPDestination, reply *utils.T
 	} else if len(storData) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		dsts := engine.TpDestinations(storData).GetDestinations()
+		dsts, err := engine.TpDestinations(storData).GetDestinations()
+		if err != nil {
+			return err
+		}
 		*reply = utils.TPDestination{
 			TPid:          attrs.TPid,
 			DestinationId: dsts[attrs.DestinationId].Id,
@@ -73,7 +77,7 @@ func (self *ApierV1) GetTPDestinationIds(attrs AttrGetTPDestinationIds, reply *[
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_DESTINATIONS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_DESTINATIONS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -87,7 +91,7 @@ func (self *ApierV1) RemTPDestination(attrs AttrGetTPDestination, reply *string)
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "DestinationId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_DESTINATIONS, attrs.TPid, attrs.DestinationId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_DESTINATIONS, attrs.TPid, attrs.DestinationId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tprates.go
+++ b/apier/v1/tprates.go
@@ -24,6 +24,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -32,7 +33,8 @@ func (self *ApierV1) SetTPRate(attrs utils.TPRate, reply *string) error {
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "RateId", "RateSlots"}); len(missing) != 0 {
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.SetTPRates(attrs.TPid, map[string][]*utils.RateSlot{attrs.RateId: attrs.RateSlots}); err != nil {
+	r := engine.APItoModelRate(&attrs)
+	if err := self.StorDb.SetTpRates(r); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -54,7 +56,11 @@ func (self *ApierV1) GetTPRate(attrs AttrGetTPRate, reply *utils.TPRate) error {
 	} else if len(rts) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		*reply = *rts[attrs.RateId]
+		rtsMap, err := engine.TpRates(rts).GetRates()
+		if err != nil {
+			return err
+		}
+		*reply = *rtsMap[attrs.RateId]
 	}
 	return nil
 }
@@ -69,7 +75,7 @@ func (self *ApierV1) GetTPRateIds(attrs AttrGetTPRateIds, reply *[]string) error
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_RATES, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_RATES, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -84,7 +90,7 @@ func (self *ApierV1) RemTPRate(attrs AttrGetTPRate, reply *string) error {
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "RateId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_RATES, attrs.TPid, attrs.RateId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_RATES, attrs.TPid, attrs.RateId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpratingplans.go
+++ b/apier/v1/tpratingplans.go
@@ -24,6 +24,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -32,7 +33,8 @@ func (self *ApierV1) SetTPRatingPlan(attrs utils.TPRatingPlan, reply *string) er
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "RatingPlanId", "RatingPlanBindings"}); len(missing) != 0 {
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.SetTPRatingPlans(attrs.TPid, map[string][]*utils.TPRatingPlanBinding{attrs.RatingPlanId: attrs.RatingPlanBindings}); err != nil {
+	rp := engine.APItoModelRatingPlan(&attrs)
+	if err := self.StorDb.SetTpRatingPlans(rp); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -55,7 +57,11 @@ func (self *ApierV1) GetTPRatingPlan(attrs AttrGetTPRatingPlan, reply *utils.TPR
 	} else if len(rps) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		*reply = utils.TPRatingPlan{TPid: attrs.TPid, RatingPlanId: attrs.RatingPlanId, RatingPlanBindings: rps[attrs.RatingPlanId]}
+		rpsMap, err := engine.TpRatingPlans(rps).GetRatingPlans()
+		if err != nil {
+			return err
+		}
+		*reply = utils.TPRatingPlan{TPid: attrs.TPid, RatingPlanId: attrs.RatingPlanId, RatingPlanBindings: rpsMap[attrs.RatingPlanId]}
 	}
 	return nil
 }
@@ -70,7 +76,7 @@ func (self *ApierV1) GetTPRatingPlanIds(attrs AttrGetTPRatingPlanIds, reply *[]s
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_RATING_PLANS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_RATING_PLANS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -85,7 +91,7 @@ func (self *ApierV1) RemTPRatingPlan(attrs AttrGetTPRatingPlan, reply *string) e
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "RatingPlanId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_RATING_PLANS, attrs.TPid, attrs.RatingPlanId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_RATING_PLANS, attrs.TPid, attrs.RatingPlanId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpratingprofiles.go
+++ b/apier/v1/tpratingprofiles.go
@@ -33,7 +33,8 @@ func (self *ApierV1) SetTPRatingProfile(attrs utils.TPRatingProfile, reply *stri
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "LoadId", "Tenant", "Category", "Direction", "Subject", "RatingPlanActivations"}); len(missing) != 0 {
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.SetTPRatingProfiles(attrs.TPid, map[string]*utils.TPRatingProfile{attrs.KeyId(): &attrs}); err != nil {
+	rpf := engine.APItoModelRatingProfile(&attrs)
+	if err := self.StorDb.SetTpRatingProfiles(rpf); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -54,16 +55,21 @@ func (self *ApierV1) GetTPRatingProfilesByLoadId(attrs utils.TPRatingProfile, re
 	if missing := utils.MissingStructFields(&attrs, mndtryFlds); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if dr, err := self.StorDb.GetTpRatingProfiles(&attrs); err != nil {
+	rpf := engine.APItoModelRatingProfile(&attrs)
+	if dr, err := self.StorDb.GetTpRatingProfiles(&rpf[0]); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if dr == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
+		rpfMap, err := engine.TpRatingProfiles(dr).GetRatingProfiles()
+		if err != nil {
+			return err
+		}
 		var rpfs []*utils.TPRatingProfile
 		if len(attrs.Subject) != 0 {
-			rpfs = []*utils.TPRatingProfile{dr[attrs.KeyId()]}
+			rpfs = []*utils.TPRatingProfile{rpfMap[attrs.KeyId()]}
 		} else {
-			for _, rpfLst := range dr {
+			for _, rpfLst := range rpfMap {
 				rpfs = append(rpfs, rpfLst)
 			}
 		}
@@ -77,7 +83,7 @@ func (self *ApierV1) GetTPRatingProfileLoadIds(attrs utils.AttrTPRatingProfileId
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_RATE_PROFILES, utils.TPDistinctIds{"loadid"}, map[string]string{
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_RATE_PROFILES, utils.TPDistinctIds{"loadid"}, map[string]string{
 		"tenant":    attrs.Tenant,
 		"tor":       attrs.Category,
 		"direction": attrs.Direction,
@@ -106,12 +112,17 @@ func (self *ApierV1) GetTPRatingProfile(attrs AttrGetTPRatingProfile, reply *uti
 	if err := tmpRpf.SetRatingProfilesId(attrs.RatingProfileId); err != nil {
 		return err
 	}
-	if rpfs, err := self.StorDb.GetTpRatingProfiles(tmpRpf); err != nil {
+	rpf := engine.APItoModelRatingProfile(tmpRpf)
+	if rpfs, err := self.StorDb.GetTpRatingProfiles(&rpf[0]); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if len(rpfs) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		rpf := rpfs[tmpRpf.KeyId()]
+		rpfMap, err := engine.TpRatingProfiles(rpfs).GetRatingProfiles()
+		if err != nil {
+			return err
+		}
+		rpf := rpfMap[tmpRpf.KeyId()]
 		tpdc := utils.TPRatingProfile{
 			TPid: attrs.TPid,
 			RatingPlanActivations: rpf.RatingPlanActivations,
@@ -134,7 +145,7 @@ func (self *ApierV1) GetTPRatingProfileIds(attrs AttrGetTPRatingProfileIds, repl
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_RATE_PROFILES, utils.TPDistinctIds{"loadid", "direction", "tenant", "category", "subject"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_RATE_PROFILES, utils.TPDistinctIds{"loadid", "direction", "tenant", "category", "subject"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -153,7 +164,7 @@ func (self *ApierV1) RemTPRatingProfile(attrs AttrGetTPRatingProfile, reply *str
 	if err := tmpRpf.SetRatingProfileId(attrs.RatingProfileId); err != nil {
 		return err
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_RATE_PROFILES, attrs.TPid, tmpRpf.Loadid, tmpRpf.Direction, tmpRpf.Tenant, tmpRpf.Category, tmpRpf.Subject); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_RATE_PROFILES, attrs.TPid, tmpRpf.Loadid, tmpRpf.Direction, tmpRpf.Tenant, tmpRpf.Category, tmpRpf.Subject); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tpsharedgroups.go
+++ b/apier/v1/tpsharedgroups.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -39,7 +40,8 @@ func (self *ApierV1) SetTPSharedGroups(attrs utils.TPSharedGroups, reply *string
 			return fmt.Errorf("%s:SharedGroup:%s:%v", utils.ERR_MANDATORY_IE_MISSING, action.Identifier, missing)
 		}
 	}*/
-	if err := self.StorDb.SetTPSharedGroups(attrs.TPid, map[string][]*utils.TPSharedGroup{attrs.SharedGroupsId: attrs.SharedGroups}); err != nil {
+	sg := engine.APItoModelSharedGroup(&attrs)
+	if err := self.StorDb.SetTpSharedGroups(sg); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -61,7 +63,11 @@ func (self *ApierV1) GetTPSharedGroups(attrs AttrGetTPSharedGroups, reply *utils
 	} else if len(sgs) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		*reply = utils.TPSharedGroups{TPid: attrs.TPid, SharedGroupsId: attrs.SharedGroupsId, SharedGroups: sgs[attrs.SharedGroupsId]}
+		sgMap, err := engine.TpSharedGroups(sgs).GetSharedGroups()
+		if err != nil {
+			return err
+		}
+		*reply = utils.TPSharedGroups{TPid: attrs.TPid, SharedGroupsId: attrs.SharedGroupsId, SharedGroups: sgMap[attrs.SharedGroupsId]}
 	}
 	return nil
 }
@@ -76,7 +82,7 @@ func (self *ApierV1) GetTPSharedGroupIds(attrs AttrGetTPSharedGroupIds, reply *[
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_SHARED_GROUPS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_SHARED_GROUPS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -91,7 +97,7 @@ func (self *ApierV1) RemTPSharedGroups(attrs AttrGetTPSharedGroups, reply *strin
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "SharedGroupsId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_SHARED_GROUPS, attrs.TPid, attrs.SharedGroupsId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_SHARED_GROUPS, attrs.TPid, attrs.SharedGroupsId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/apier/v1/tptimings.go
+++ b/apier/v1/tptimings.go
@@ -22,6 +22,7 @@ import (
 	"errors"
 	"fmt"

+	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )

@@ -30,7 +31,8 @@ func (self *ApierV1) SetTPTiming(attrs utils.ApierTPTiming, reply *string) error
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "TimingId", "Years", "Months", "MonthDays", "WeekDays", "Time"}); len(missing) != 0 {
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.SetTPTiming(&attrs); err != nil {
+	tm := engine.APItoModelTiming(&attrs)
+	if err := self.StorDb.SetTpTimings([]engine.TpTiming{*tm}); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	}
 	*reply = "OK"
@@ -52,7 +54,11 @@ func (self *ApierV1) GetTPTiming(attrs AttrGetTPTiming, reply *utils.ApierTPTimi
 	} else if len(tms) == 0 {
 		return errors.New(utils.ERR_NOT_FOUND)
 	} else {
-		*reply = *tms[attrs.TimingId]
+		tmMap, err := engine.TpTimings(tms).GetApierTimings()
+		if err != nil {
+			return err
+		}
+		*reply = *tmMap[attrs.TimingId]
 	}
 	return nil
 }
@@ -67,7 +73,7 @@ func (self *ApierV1) GetTPTimingIds(attrs AttrGetTPTimingIds, reply *[]string) e
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if ids, err := self.StorDb.GetTPTableIds(attrs.TPid, utils.TBL_TP_TIMINGS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
+	if ids, err := self.StorDb.GetTpTableIds(attrs.TPid, utils.TBL_TP_TIMINGS, utils.TPDistinctIds{"tag"}, nil, &attrs.Paginator); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else if ids == nil {
 		return errors.New(utils.ERR_NOT_FOUND)
@@ -82,7 +88,7 @@ func (self *ApierV1) RemTPTiming(attrs AttrGetTPTiming, reply *string) error {
 	if missing := utils.MissingStructFields(&attrs, []string{"TPid", "TimingId"}); len(missing) != 0 { //Params missing
 		return fmt.Errorf("%s:%v", utils.ERR_MANDATORY_IE_MISSING, missing)
 	}
-	if err := self.StorDb.RemTPData(utils.TBL_TP_TIMINGS, attrs.TPid, attrs.TimingId); err != nil {
+	if err := self.StorDb.RemTpData(utils.TBL_TP_TIMINGS, attrs.TPid, attrs.TimingId); err != nil {
 		return fmt.Errorf("%s:%s", utils.ERR_SERVER_ERROR, err.Error())
 	} else {
 		*reply = "OK"
--- a/engine/model_helpers.go
+++ b/engine/model_helpers.go
@@ -154,6 +154,23 @@ func (tps TpTimings) GetTimings() (map[string]*utils.TPTiming, error) {
 	return timings, nil
 }

+func (tps TpTimings) GetApierTimings() (map[string]*utils.ApierTPTiming, error) {
+	timings := make(map[string]*utils.ApierTPTiming)
+	for _, tp := range tps {
+		rt := &utils.ApierTPTiming{
+			TPid:      tp.Tpid,
+			TimingId:  tp.Tag,
+			Years:     tp.Years,
+			Months:    tp.Months,
+			MonthDays: tp.MonthDays,
+			WeekDays:  tp.WeekDays,
+			Time:      tp.Time,
+		}
+		timings[tp.Tag] = rt
+	}
+	return timings, nil
+}
+
 type TpRates []TpRate

 func (tps TpRates) GetRates() (map[string]*utils.TPRate, error) {
--- a/scheduler/scheduler.go
+++ b/scheduler/scheduler.go
@@ -28,7 +28,7 @@ import (
 )

 type Scheduler struct {
-	queue       engine.ActionTimingPriotityList
+	queue       engine.ActionPlanPriotityList
 	timer       *time.Timer
 	restartLoop chan bool
 	sync.Mutex
@@ -73,18 +73,18 @@ func (s *Scheduler) Loop() {
 	}
 }

-func (s *Scheduler) LoadActionTimings(storage engine.AccountingStorage) {
-	actionTimings, err := storage.GetAllActionTimings()
+func (s *Scheduler) LoadActionPlans(storage engine.AccountingStorage) {
+	actionTimings, err := storage.GetAllActionPlans()
 	if err != nil {
 		engine.Logger.Warning(fmt.Sprintf("Cannot get action timings: %v", err))
 	}
 	// recreate the queue
 	s.Lock()
-	s.queue = engine.ActionTimingPriotityList{}
+	s.queue = engine.ActionPlanPriotityList{}
 	for key, ats := range actionTimings {
 		toBeSaved := false
 		isAsap := false
-		newAts := make([]*engine.ActionTiming, 0) // will remove the one time runs from the database
+		newAts := make([]*engine.ActionPlan, 0) // will remove the one time runs from the database
 		for _, at := range ats {
 			isAsap = at.IsASAP()
 			toBeSaved = toBeSaved || isAsap
@@ -108,7 +108,7 @@ func (s *Scheduler) LoadActionTimings(storage engine.AccountingStorage) {
 		}
 		if toBeSaved {
 			engine.AccLock.Guard(func() (interface{}, error) {
-				storage.SetActionTimings(key, newAts)
+				storage.SetActionPlans(key, newAts)
 				return 0, nil
 			}, engine.ACTION_TIMING_PREFIX)
 		}
@@ -124,6 +124,6 @@ func (s *Scheduler) Restart() {
 	}
 }

-func (s *Scheduler) GetQueue() engine.ActionTimingPriotityList {
+func (s *Scheduler) GetQueue() engine.ActionPlanPriotityList {
 	return s.queue
 }