mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-12 02:26:26 +05:00
832 lines
22 KiB
Go
Executable File
832 lines
22 KiB
Go
Executable File
/*
|
|
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
|
|
Copyright (C) ITsysCOM GmbH
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
package engine
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"github.com/cgrates/cgrates/utils"
|
|
)
|
|
|
|
//implement LoadReader interface
|
|
func (ms *MapStorage) GetTpIds(colName string) (ids []string, err error) {
|
|
return nil, utils.ErrNotImplemented
|
|
}
|
|
|
|
func (ms *MapStorage) GetTpTableIds(tpid, table string, distinct utils.TPDistinctIds,
|
|
filters map[string]string, paginator *utils.PaginatorWithSearch) (ids []string, err error) {
|
|
key := table + utils.CONCATENATED_KEY_SEP + tpid
|
|
fullIDs, _ := ms.GetKeysForPrefix(key)
|
|
for _, fullID := range fullIDs {
|
|
var buildedID string
|
|
sliceID := strings.Split(fullID[len(key)+1:], utils.CONCATENATED_KEY_SEP)
|
|
|
|
for i := 0; i < len(distinct); i++ {
|
|
if len(buildedID) == 0 {
|
|
buildedID += sliceID[len(sliceID)-i-1]
|
|
} else {
|
|
buildedID += utils.CONCATENATED_KEY_SEP + sliceID[len(sliceID)-i+1]
|
|
}
|
|
}
|
|
ids = append(ids, buildedID)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPTimings(tpid, id string) (timings []*utils.ApierTPTiming, err error) {
|
|
key := utils.TBLTPTimings + utils.CONCATENATED_KEY_SEP + tpid
|
|
if id != utils.EmptyString {
|
|
key = utils.TBLTPTimings + utils.ConcatenatedKey(tpid, id)
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.ApierTPTiming
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
timings = append(timings, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(timings) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPDestinations(tpid, id string) (dsts []*utils.TPDestination, err error) {
|
|
key := utils.TBLTPDestinations + utils.CONCATENATED_KEY_SEP + tpid
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tpid
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPDestination
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
dsts = append(dsts, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(dsts) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPRates(tpid, id string) (rates []*utils.TPRate, err error) {
|
|
key := utils.TBLTPRates + utils.CONCATENATED_KEY_SEP + tpid
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tpid
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPRate
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
for _, rs := range result.RateSlots {
|
|
rs.SetDurations()
|
|
}
|
|
rates = append(rates, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(rates) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPDestinationRates(tpid, id string,
|
|
paginator *utils.Paginator) (dRates []*utils.TPDestinationRate, err error) {
|
|
key := utils.TBLTPDestinationRates + utils.CONCATENATED_KEY_SEP + tpid
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tpid
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPDestinationRate
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
dRates = append(dRates, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(dRates) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
// handle paginator
|
|
return
|
|
}
|
|
func (ms *MapStorage) GetTPRatingPlans(string, string, *utils.Paginator) (rPlans []*utils.TPRatingPlan, err error) {
|
|
return nil, utils.ErrNotImplemented
|
|
}
|
|
func (ms *MapStorage) GetTPRatingProfiles(filter *utils.TPRatingProfile) (rProfiles []*utils.TPRatingProfile, err error) {
|
|
return nil, utils.ErrNotImplemented
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPSharedGroups(tpid, id string) (sGroups []*utils.TPSharedGroups, err error) {
|
|
key := utils.TBLTPSharedGroups + utils.CONCATENATED_KEY_SEP + tpid
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tpid
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPSharedGroups
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
sGroups = append(sGroups, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(sGroups) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPActions(tpid, id string) (actions []*utils.TPActions, err error) {
|
|
key := utils.TBLTPActions + utils.CONCATENATED_KEY_SEP + tpid
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tpid
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPActions
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
actions = append(actions, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(actions) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPActionPlans(tpid, id string) (aPlans []*utils.TPActionPlan, err error) {
|
|
key := utils.TBLTPActionPlans + utils.CONCATENATED_KEY_SEP + tpid
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tpid
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPActionPlan
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
aPlans = append(aPlans, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(aPlans) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPActionTriggers(tpid, id string) (aTriggers []*utils.TPActionTriggers, err error) {
|
|
key := utils.TBLTPActionTriggers + utils.CONCATENATED_KEY_SEP + tpid
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tpid
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPActionTriggers
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
aTriggers = append(aTriggers, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(aTriggers) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
func (ms *MapStorage) GetTPAccountActions(filter *utils.TPAccountActions) (accounts []*utils.TPAccountActions, err error) {
|
|
return nil, utils.ErrNotImplemented
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPResources(tpid, tenant, id string) (resources []*utils.TPResourceProfile, err error) {
|
|
key := utils.TBLTPResources + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPResourceProfile
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
resources = append(resources, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(resources) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPStats(tpid, tenant, id string) (stats []*utils.TPStatProfile, err error) {
|
|
key := utils.TBLTPStats + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPStatProfile
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
stats = append(stats, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(stats) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPThresholds(tpid, tenant, id string) (ths []*utils.TPThresholdProfile, err error) {
|
|
key := utils.TBLTPThresholds + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPThresholdProfile
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
ths = append(ths, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(ths) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPFilters(tpid, tenant, id string) (fltrs []*utils.TPFilterProfile, err error) {
|
|
key := utils.TBLTPFilters + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPFilterProfile
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
fltrs = append(fltrs, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(fltrs) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPSuppliers(tpid, tenant, id string) (supps []*utils.TPSupplierProfile, err error) {
|
|
key := utils.TBLTPSuppliers + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPSupplierProfile
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
supps = append(supps, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(supps) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPAttributes(tpid, tenant, id string) (attrs []*utils.TPAttributeProfile, err error) {
|
|
key := utils.TBLTPAttributes + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPAttributeProfile
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
attrs = append(attrs, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(attrs) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPChargers(tpid, tenant, id string) (cpps []*utils.TPChargerProfile, err error) {
|
|
key := utils.TBLTPChargers + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPChargerProfile
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
cpps = append(cpps, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(cpps) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPDispatcherProfiles(tpid, tenant, id string) (dpps []*utils.TPDispatcherProfile, err error) {
|
|
key := utils.TBLTPDispatchers + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPDispatcherProfile
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
dpps = append(dpps, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(dpps) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) GetTPDispatcherHosts(tpid, tenant, id string) (dpps []*utils.TPDispatcherHost, err error) {
|
|
key := utils.TBLTPDispatcherHosts + utils.CONCATENATED_KEY_SEP + tpid
|
|
if tenant != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + tenant
|
|
}
|
|
if id != utils.EmptyString {
|
|
key += utils.CONCATENATED_KEY_SEP + id
|
|
}
|
|
ms.mu.RLock()
|
|
defer ms.mu.RUnlock()
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
for _, id := range ids {
|
|
if values, ok := ms.dict[id]; ok {
|
|
var result *utils.TPDispatcherHost
|
|
if err = ms.ms.Unmarshal(values, &result); err != nil {
|
|
return nil, err
|
|
}
|
|
dpps = append(dpps, result)
|
|
} else {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
}
|
|
if len(dpps) == 0 {
|
|
return nil, utils.ErrNotFound
|
|
}
|
|
return
|
|
}
|
|
|
|
//implement LoadWriter interface
|
|
func (ms *MapStorage) RemTpData(table, tpid string, args map[string]string) (err error) {
|
|
if table == utils.EmptyString {
|
|
return ms.Flush(utils.EmptyString)
|
|
}
|
|
key := table + utils.CONCATENATED_KEY_SEP + tpid
|
|
if args != nil {
|
|
for _, val := range args {
|
|
key += utils.CONCATENATED_KEY_SEP + val
|
|
}
|
|
}
|
|
ids, _ := ms.GetKeysForPrefix(key)
|
|
ms.mu.Lock()
|
|
for _, id := range ids {
|
|
delete(ms.dict, id)
|
|
}
|
|
ms.mu.Unlock()
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPTimings(timings []*utils.ApierTPTiming) (err error) {
|
|
if len(timings) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, timing := range timings {
|
|
result, err := ms.ms.Marshal(timing)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPTimings, timing.TPid, timing.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
func (ms *MapStorage) SetTPDestinations(dests []*utils.TPDestination) (err error) {
|
|
if len(dests) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, destination := range dests {
|
|
result, err := ms.ms.Marshal(destination)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPDestinations, destination.TPid, destination.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPRates(rates []*utils.TPRate) (err error) {
|
|
if len(rates) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, rate := range rates {
|
|
result, err := ms.ms.Marshal(rate)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPRates, rate.TPid, rate.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPDestinationRates(dRates []*utils.TPDestinationRate) (err error) {
|
|
if len(dRates) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, dRate := range dRates {
|
|
result, err := ms.ms.Marshal(dRate)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPDestinationRates, dRate.TPid, dRate.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPRatingPlans(ratingPlans []*utils.TPRatingPlan) (err error) {
|
|
return utils.ErrNotImplemented
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPRatingProfiles(ratingProfiles []*utils.TPRatingProfile) (err error) {
|
|
return utils.ErrNotImplemented
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPSharedGroups(groups []*utils.TPSharedGroups) (err error) {
|
|
if len(groups) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, group := range groups {
|
|
result, err := ms.ms.Marshal(group)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPSharedGroups, group.TPid, group.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPActions(acts []*utils.TPActions) (err error) {
|
|
if len(acts) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, action := range acts {
|
|
result, err := ms.ms.Marshal(action)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPActions, action.TPid, action.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPActionPlans(aPlans []*utils.TPActionPlan) (err error) {
|
|
if len(aPlans) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, aPlan := range aPlans {
|
|
result, err := ms.ms.Marshal(aPlan)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPActionPlans, aPlan.TPid, aPlan.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPActionTriggers(aTriggers []*utils.TPActionTriggers) (err error) {
|
|
if len(aTriggers) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, aTrigger := range aTriggers {
|
|
result, err := ms.ms.Marshal(aTrigger)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPActionTriggers, aTrigger.TPid, aTrigger.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPAccountActions(accActions []*utils.TPAccountActions) (err error) {
|
|
return utils.ErrNotImplemented
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPResources(resources []*utils.TPResourceProfile) (err error) {
|
|
if len(resources) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, resource := range resources {
|
|
result, err := ms.ms.Marshal(resource)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPResources, resource.TPid, resource.Tenant, resource.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
func (ms *MapStorage) SetTPStats(stats []*utils.TPStatProfile) (err error) {
|
|
if len(stats) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, stat := range stats {
|
|
result, err := ms.ms.Marshal(stat)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPStats, stat.TPid, stat.Tenant, stat.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
func (ms *MapStorage) SetTPThresholds(thresholds []*utils.TPThresholdProfile) (err error) {
|
|
if len(thresholds) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, threshold := range thresholds {
|
|
result, err := ms.ms.Marshal(threshold)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPThresholds, threshold.TPid, threshold.Tenant, threshold.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
func (ms *MapStorage) SetTPFilters(filters []*utils.TPFilterProfile) (err error) {
|
|
if len(filters) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, filter := range filters {
|
|
result, err := ms.ms.Marshal(filter)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPFilters, filter.TPid, filter.Tenant, filter.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPSuppliers(suppliers []*utils.TPSupplierProfile) (err error) {
|
|
if len(suppliers) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, supplier := range suppliers {
|
|
result, err := ms.ms.Marshal(supplier)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPSuppliers, supplier.TPid, supplier.Tenant, supplier.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
func (ms *MapStorage) SetTPAttributes(attributes []*utils.TPAttributeProfile) (err error) {
|
|
if len(attributes) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, attribute := range attributes {
|
|
result, err := ms.ms.Marshal(attribute)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPAttributes, attribute.TPid, attribute.Tenant, attribute.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
func (ms *MapStorage) SetTPChargers(cpps []*utils.TPChargerProfile) (err error) {
|
|
if len(cpps) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, cpp := range cpps {
|
|
result, err := ms.ms.Marshal(cpp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPChargers, cpp.TPid, cpp.Tenant, cpp.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
func (ms *MapStorage) SetTPDispatcherProfiles(dpps []*utils.TPDispatcherProfile) (err error) {
|
|
if len(dpps) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, dpp := range dpps {
|
|
result, err := ms.ms.Marshal(dpp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPDispatchers, dpp.TPid, dpp.Tenant, dpp.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
func (ms *MapStorage) SetTPDispatcherHosts(dpps []*utils.TPDispatcherHost) (err error) {
|
|
if len(dpps) == 0 {
|
|
return nil
|
|
}
|
|
ms.mu.Lock()
|
|
defer ms.mu.Unlock()
|
|
for _, dpp := range dpps {
|
|
result, err := ms.ms.Marshal(dpp)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ms.dict[utils.ConcatenatedKey(utils.TBLTPDispatcherHosts, dpp.TPid, dpp.Tenant, dpp.ID)] = result
|
|
}
|
|
return
|
|
}
|
|
|
|
//implement CdrStorage interface
|
|
func (ms *MapStorage) SetCDR(cdr *CDR, allowUpdate bool) (err error) {
|
|
return utils.ErrNotImplemented
|
|
}
|
|
func (ms *MapStorage) RemoveSMCost(smc *SMCost) (err error) {
|
|
return utils.ErrNotImplemented
|
|
}
|
|
func (ms *MapStorage) RemoveSMCosts(qryFltr *utils.SMCostFilter) error {
|
|
return utils.ErrNotImplemented
|
|
}
|
|
func (ms *MapStorage) GetCDRs(filter *utils.CDRsFilter, remove bool) (cdrs []*CDR, count int64, err error) {
|
|
return nil, 0, utils.ErrNotImplemented
|
|
}
|
|
|
|
func (ms *MapStorage) GetSMCosts(cgrid, runid, originHost, originIDPrfx string) (smCosts []*SMCost, err error) {
|
|
return nil, utils.ErrNotImplemented
|
|
}
|