move rankings to dedicated package

utils/rankings.go

@@ -0,0 +1,447 @@
+/*
+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 utils
+
+import (
+	"sort"
+	"strings"
+	"sync"
+	"time"
+)
+
+type RankingProfileWithAPIOpts struct {
+	*RankingProfile
+	APIOpts map[string]any
+}
+
+type RankingProfile struct {
+	Tenant            string   // Tenant this profile belongs to
+	ID                string   // Profile identification
+	Schedule          string   // Cron schedule this profile should run at
+	StatIDs           []string // List of stat instances to query
+	MetricIDs         []string // Filter out only specific metrics in reply for sorting
+	Sorting           string   // Sorting strategy. Possible values: <*asc|*desc>
+	SortingParameters []string // Sorting parameters: depending on sorting type, list of metric ids for now with optional true or false in case of reverse logic is desired
+	Stored            bool     // Offline storage activation for this profile
+	ThresholdIDs      []string // List of threshold IDs to limit this Ranking to. *none to disable threshold processing for it.
+}
+
+func (sgp *RankingProfile) TenantID() string {
+	return ConcatenatedKey(sgp.Tenant, sgp.ID)
+}
+
+// Clone will clone a RankingProfile
+func (rkP *RankingProfile) Clone() (cln *RankingProfile) {
+	cln = &RankingProfile{
+		Tenant:   rkP.Tenant,
+		ID:       rkP.ID,
+		Schedule: rkP.Schedule,
+		Sorting:  rkP.Sorting,
+	}
+	if rkP.StatIDs != nil {
+		cln.StatIDs = make([]string, len(rkP.StatIDs))
+		copy(cln.StatIDs, rkP.StatIDs)
+	}
+	if rkP.MetricIDs != nil {
+		cln.MetricIDs = make([]string, len(rkP.MetricIDs))
+		copy(cln.MetricIDs, rkP.MetricIDs)
+	}
+	if rkP.SortingParameters != nil {
+
+		cln.SortingParameters = make([]string, len(rkP.SortingParameters))
+		copy(cln.SortingParameters, rkP.SortingParameters)
+	}
+	if rkP.ThresholdIDs != nil {
+		cln.ThresholdIDs = make([]string, len(rkP.ThresholdIDs))
+		copy(cln.ThresholdIDs, rkP.ThresholdIDs)
+	}
+	return
+}
+
+// RankingProfileLockKey returns the ID used to lock a RankingProfile with guardian
+func RankingProfileLockKey(tnt, id string) string {
+	return ConcatenatedKey(CacheRankingProfiles, tnt, id)
+}
+func NewRankingFromProfile(rkP *RankingProfile) (rk *Ranking) {
+	rk = &Ranking{
+		Tenant:  rkP.Tenant,
+		ID:      rkP.ID,
+		Sorting: rkP.Sorting,
+		Metrics: make(map[string]map[string]float64),
+
+		rkPrfl:    rkP,
+		metricIDs: NewStringSet(rkP.MetricIDs),
+	}
+	if rkP.SortingParameters != nil {
+		rk.SortingParameters = make([]string, len(rkP.SortingParameters))
+		copy(rk.SortingParameters, rkP.SortingParameters)
+	}
+	return
+}
+
+type RankingWithAPIOpts struct {
+	*Ranking
+	APIOpts map[string]any
+}
+
+// Ranking is one unit out of a profile
+type Ranking struct {
+	rMux sync.RWMutex
+
+	Tenant            string
+	ID                string
+	LastUpdate        time.Time
+	Metrics           map[string]map[string]float64 // map[statID]map[metricID]metricValue
+	Sorting           string
+	SortingParameters []string
+
+	SortedStatIDs []string
+
+	rkPrfl    *RankingProfile // store here the ranking profile so we can have it at hands further
+	metricIDs StringSet       // convert the metricIDs here for faster matching
+
+}
+
+func (r *Ranking) TenantID() string {
+	return ConcatenatedKey(r.Tenant, r.ID)
+}
+
+// AsRankingSummary converts the Ranking instance into a RankingSummary one
+func (rk *Ranking) AsRankingSummary() (rkSm *RankingSummary) {
+	rkSm = &RankingSummary{
+		Tenant:     rk.Tenant,
+		ID:         rk.ID,
+		LastUpdate: rk.LastUpdate,
+	}
+	rkSm.SortedStatIDs = make([]string, len(rk.SortedStatIDs))
+	copy(rkSm.SortedStatIDs, rk.SortedStatIDs)
+	return
+}
+
+type rankingSorter interface {
+	sortStatIDs() []string // sortStatIDs returns the sorted list of statIDs
+}
+
+// RankingSortStats will return the list of sorted statIDs out of the sortingData map
+func RankingSortStats(sortingType string, sortingParams []string,
+	Metrics map[string]map[string]float64) (sortedStatIDs []string, err error) {
+	var rnkSrtr rankingSorter
+	if rnkSrtr, err = newRankingSorter(sortingType, sortingParams, Metrics); err != nil {
+		return
+	}
+	return rnkSrtr.sortStatIDs(), nil
+}
+
+// newRankingSorter is the constructor for various ranking sorters
+//
+//	returns error if the sortingType is not implemented
+func newRankingSorter(sortingType string, sortingParams []string,
+	Metrics map[string]map[string]float64) (rkStr rankingSorter, err error) {
+	switch sortingType {
+	default:
+		err = ErrPrefixNotErrNotImplemented(sortingType)
+		return
+	case MetaDesc:
+		return newRankingDescSorter(sortingParams, Metrics), nil
+	case MetaAsc:
+		return newRankingAscSorter(sortingParams, Metrics), nil
+	}
+}
+
+// newRankingDescSorter is a constructor for rankingDescSorter
+func newRankingDescSorter(sortingParams []string,
+	Metrics map[string]map[string]float64) (rkDsrtr *rankingDescSorter) {
+	clnSp := make([]string, len(sortingParams))
+	sPReversed := make(StringSet)
+	for i, sP := range sortingParams { // clean the sortingParams, out of param:false or param:true definitions
+		sPSlc := strings.Split(sP, InInFieldSep)
+		clnSp[i] = sPSlc[0]
+		if len(sPSlc) > 1 && sPSlc[1] == FalseStr {
+			sPReversed.Add(sPSlc[0]) // param defined as param:false which should be added to reversing comparison
+		}
+	}
+	rkDsrtr = &rankingDescSorter{
+		clnSp,
+		sPReversed,
+		Metrics,
+		make([]string, 0, len(Metrics))}
+	for statID := range rkDsrtr.Metrics {
+		rkDsrtr.statIDs = append(rkDsrtr.statIDs, statID)
+	}
+	return
+}
+
+// rankingDescSorter will sort data descendent for metrics in sortingParams or random if all equal
+type rankingDescSorter struct {
+	sMetricIDs []string
+	sMetricRev StringSet // list of exceptios for sortingParams, reverting the sorting logic
+	Metrics    map[string]map[string]float64
+
+	statIDs []string // list of keys of the Metrics
+}
+
+// sortStatIDs implements rankingSorter interface
+func (rkDsrtr *rankingDescSorter) sortStatIDs() []string {
+	if len(rkDsrtr.statIDs) == 0 {
+		return rkDsrtr.statIDs
+	}
+	sort.Slice(rkDsrtr.statIDs, func(i, j int) bool {
+		for _, metricID := range rkDsrtr.sMetricIDs {
+			val1, hasMetric1 := rkDsrtr.Metrics[rkDsrtr.statIDs[i]][metricID]
+			val2, hasMetric2 := rkDsrtr.Metrics[rkDsrtr.statIDs[j]][metricID]
+			if !hasMetric1 && !hasMetric2 {
+				continue
+			}
+			if !hasMetric1 {
+				return false
+			}
+			if !hasMetric2 {
+				return true
+			}
+			//in case we have the same value for the current metricID we skip to the next one
+			if val1 == val2 {
+				continue
+			}
+			ret := val1 > val2
+			if rkDsrtr.sMetricRev.Has(metricID) {
+				ret = !ret
+			}
+			return ret
+		}
+		//in case that we have the same value for all params we return randomly
+		return BoolGenerator().RandomBool()
+	})
+	return rkDsrtr.statIDs
+}
+
+// newRankingAscSorter is a constructor for rankingAscSorter
+func newRankingAscSorter(sortingParams []string,
+	Metrics map[string]map[string]float64) (rkASrtr *rankingAscSorter) {
+	clnSp := make([]string, len(sortingParams))
+	sPReversed := make(StringSet)
+	for i, sP := range sortingParams { // clean the sortingParams, out of param:false or param:true definitions
+		sPSlc := strings.Split(sP, InInFieldSep)
+		clnSp[i] = sPSlc[0]
+		if len(sPSlc) > 1 && sPSlc[1] == FalseStr {
+			sPReversed.Add(sPSlc[0]) // param defined as param:false which should be added to reversing comparison
+		}
+	}
+	rkASrtr = &rankingAscSorter{
+		clnSp,
+		sPReversed,
+		Metrics,
+		make([]string, 0, len(Metrics))}
+	for statID := range rkASrtr.Metrics {
+		rkASrtr.statIDs = append(rkASrtr.statIDs, statID)
+	}
+	return
+}
+
+// rankingAscSorter will sort data ascendent for metrics in sortingParams or randomly if all equal
+type rankingAscSorter struct {
+	sMetricIDs []string
+	sMetricRev StringSet // list of exceptios for sortingParams, reverting the sorting logic
+	Metrics    map[string]map[string]float64
+
+	statIDs []string // list of keys of the Metrics
+}
+
+// sortStatIDs implements rankingSorter interface
+func (rkASrtr *rankingAscSorter) sortStatIDs() []string {
+	if len(rkASrtr.statIDs) == 0 {
+		return rkASrtr.statIDs
+	}
+	sort.Slice(rkASrtr.statIDs, func(i, j int) bool {
+		for _, metricID := range rkASrtr.sMetricIDs {
+			val1, hasMetric1 := rkASrtr.Metrics[rkASrtr.statIDs[i]][metricID]
+			val2, hasMetric2 := rkASrtr.Metrics[rkASrtr.statIDs[j]][metricID]
+			if !hasMetric1 && !hasMetric2 {
+				continue
+			}
+			if !hasMetric1 {
+				return false
+			}
+			if !hasMetric2 {
+				return true
+			}
+			//in case we have the same value for the current metricID we skip to the next one
+			if val1 == val2 {
+				continue
+			}
+			ret := val2 > val1
+			if rkASrtr.sMetricRev.Has(metricID) {
+				ret = !ret // reversed logic in case of metric:false in params
+			}
+			return ret
+		}
+		//in case that we have the same value for all params we return randomly
+		return BoolGenerator().RandomBool()
+	})
+	return rkASrtr.statIDs
+}
+
+// RankingSummary is the event sent to TrendS and EEs
+type RankingSummary struct {
+	Tenant        string
+	ID            string
+	LastUpdate    time.Time
+	SortedStatIDs []string
+}
+
+func (tp *RankingProfile) Set(path []string, val any, _ bool) (err error) {
+	if len(path) != 1 {
+		return ErrWrongPath
+	}
+
+	switch path[0] {
+	default:
+		return ErrWrongPath
+	case Tenant:
+		tp.Tenant = IfaceAsString(val)
+	case ID:
+		tp.ID = IfaceAsString(val)
+	case Schedule:
+		tp.Schedule = IfaceAsString(val)
+	case StatIDs:
+		var valA []string
+		valA, err = IfaceAsStringSlice(val)
+		tp.StatIDs = append(tp.StatIDs, valA...)
+	case MetricIDs:
+		var valA []string
+		valA, err = IfaceAsStringSlice(val)
+		tp.MetricIDs = append(tp.MetricIDs, valA...)
+	case Sorting:
+		tp.Sorting = IfaceAsString(val)
+	case SortingParameters:
+		var valA []string
+		valA, err = IfaceAsStringSlice(val)
+		tp.SortingParameters = append(tp.SortingParameters, valA...)
+	case Stored:
+		tp.Stored, err = IfaceAsBool(val)
+	case ThresholdIDs:
+		var valA []string
+		valA, err = IfaceAsStringSlice(val)
+		tp.ThresholdIDs = append(tp.ThresholdIDs, valA...)
+	}
+	return
+}
+
+func (tp *RankingProfile) Merge(v2 any) {
+	vi := v2.(*RankingProfile)
+	if len(vi.Tenant) != 0 {
+		tp.Tenant = vi.Tenant
+	}
+	if len(vi.ID) != 0 {
+		tp.ID = vi.ID
+	}
+	if len(vi.Schedule) != 0 {
+		tp.Schedule = vi.Schedule
+	}
+	tp.StatIDs = append(tp.StatIDs, vi.StatIDs...)
+	tp.MetricIDs = append(tp.MetricIDs, vi.MetricIDs...)
+	tp.SortingParameters = append(tp.SortingParameters, vi.SortingParameters...)
+	tp.ThresholdIDs = append(tp.ThresholdIDs, vi.ThresholdIDs...)
+	if len(vi.Sorting) != 0 {
+		tp.Sorting = vi.Sorting
+	}
+	if vi.Stored {
+		tp.Stored = vi.Stored
+	}
+}
+
+func (tp *RankingProfile) String() string { return ToJSON(tp) }
+func (tp *RankingProfile) FieldAsString(fldPath []string) (_ string, err error) {
+	var val any
+	if val, err = tp.FieldAsInterface(fldPath); err != nil {
+		return
+	}
+	return IfaceAsString(val), nil
+}
+func (tp *RankingProfile) FieldAsInterface(fldPath []string) (_ any, err error) {
+	if len(fldPath) != 1 {
+		return nil, ErrNotFound
+	}
+	switch fldPath[0] {
+	default:
+		fld, idx := GetPathIndex(fldPath[0])
+		if idx != nil {
+			switch fld {
+			case StatIDs:
+				if *idx < len(tp.StatIDs) {
+					return tp.StatIDs[*idx], nil
+				}
+			case MetricIDs:
+				if *idx < len(tp.MetricIDs) {
+					return tp.MetricIDs[*idx], nil
+				}
+			case SortingParameters:
+				if *idx < len(tp.SortingParameters) {
+					return tp.SortingParameters[*idx], nil
+				}
+			case ThresholdIDs:
+				if *idx < len(tp.ThresholdIDs) {
+					return tp.ThresholdIDs[*idx], nil
+				}
+			}
+		}
+		return nil, ErrNotFound
+	case Tenant:
+		return tp.Tenant, nil
+	case ID:
+		return tp.ID, nil
+	case Schedule:
+		return tp.Schedule, nil
+	case Sorting:
+		return tp.Sorting, nil
+	case Stored:
+		return tp.Stored, nil
+	}
+}
+
+// Config returns the ranking's profile configuration.
+func (r *Ranking) Config() *RankingProfile {
+	return r.rkPrfl
+}
+
+func (t *Ranking) SetConfig(rp *RankingProfile) {
+	t.rkPrfl = rp
+}
+
+// Lock locks the ranking mutex.
+func (r *Ranking) Lock() {
+	r.rMux.Lock()
+}
+
+// Unlock unlocks the ranking mutex.
+func (r *Ranking) Unlock() {
+	r.rMux.Unlock()
+}
+
+// RLock locks the ranking mutex for reading.
+func (r *Ranking) RLock() {
+	r.rMux.RLock()
+}
+
+// RUnlock unlocks the read lock on the ranking mutex.
+func (r *Ranking) RUnlock() {
+	r.rMux.RUnlock()
+}
+
+func (r *Ranking) MetricIDs() StringSet {
+	return r.metricIDs
+}

utils/rankings_test.go

@@ -0,0 +1,699 @@
+/*
+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 utils
+
+import (
+	"encoding/json"
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestRankingProfileTenantID(t *testing.T) {
+	tests := []struct {
+		name     string
+		profile  RankingProfile
+		expected string
+	}{
+		{
+			name:     "Tenant and ID",
+			profile:  RankingProfile{Tenant: "cgrates.org", ID: "1"},
+			expected: "cgrates.org:1",
+		},
+		{
+			name:     "Empty tenant",
+			profile:  RankingProfile{ID: "2"},
+			expected: ":2",
+		},
+		{
+			name:     "Empty ID",
+			profile:  RankingProfile{Tenant: "cgrates.org"},
+			expected: "cgrates.org:",
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := tc.profile.TenantID()
+			if got != tc.expected {
+				t.Errorf("TenantID() = %v, want %v", got, tc.expected)
+			}
+		})
+	}
+}
+
+func TestRankingProfileClone(t *testing.T) {
+	original := &RankingProfile{
+		Tenant:   "cgrates.org",
+		ID:       "ID1",
+		Schedule: "@every 1sec",
+		Sorting:  "asc",
+	}
+
+	cloned := original.Clone()
+
+	if cloned.Tenant != original.Tenant {
+		t.Errorf("Expected Tenant %s, got %s", original.Tenant, cloned.Tenant)
+	}
+	if cloned.ID != original.ID {
+		t.Errorf("Expected ID %s, got %s", original.ID, cloned.ID)
+	}
+	if cloned.Schedule != original.Schedule {
+		t.Errorf("Expected Schedule %s, got %s", original.Schedule, cloned.Schedule)
+	}
+	if cloned.Sorting != original.Sorting {
+		t.Errorf("Expected Sorting %s, got %s", original.Sorting, cloned.Sorting)
+	}
+
+	if cloned == original {
+		t.Error("Clone should return a new instance, but it returned the same reference")
+	}
+}
+
+func TestNewRankingFromProfile(t *testing.T) {
+	profile := &RankingProfile{
+		Tenant:            "cgrates.org",
+		ID:                "ID1",
+		Sorting:           "asc",
+		MetricIDs:         []string{"metric1", "metric2"},
+		SortingParameters: []string{"param1", "param2"},
+	}
+
+	ranking := NewRankingFromProfile(profile)
+
+	if ranking.Tenant != profile.Tenant {
+		t.Errorf("Expected Tenant %s, got %s", profile.Tenant, ranking.Tenant)
+	}
+	if ranking.ID != profile.ID {
+		t.Errorf("Expected ID %s, got %s", profile.ID, ranking.ID)
+	}
+	if ranking.Sorting != profile.Sorting {
+		t.Errorf("Expected Sorting %s, got %s", profile.Sorting, ranking.Sorting)
+	}
+
+	if ranking.Metrics == nil {
+		t.Error("Expected Metrics map to be initialized, but it is nil")
+	}
+
+	expectedMetricIDs := NewStringSet(profile.MetricIDs)
+	if !ranking.metricIDs.Equals(expectedMetricIDs) {
+		t.Errorf("Expected metricIDs %v, got %v", expectedMetricIDs, ranking.metricIDs)
+	}
+
+	if len(ranking.SortingParameters) != len(profile.SortingParameters) {
+		t.Errorf("Expected SortingParameters length %d, got %d", len(profile.SortingParameters), len(ranking.SortingParameters))
+	}
+	for i, param := range profile.SortingParameters {
+		if ranking.SortingParameters[i] != param {
+			t.Errorf("Expected SortingParameters[%d] %s, got %s", i, param, ranking.SortingParameters[i])
+		}
+	}
+
+	if ranking.rkPrfl != profile {
+		t.Error("Expected rkPrfl to reference the original profile")
+	}
+}
+
+func TestRankingTenantID(t *testing.T) {
+	r := &Ranking{
+		Tenant: "cgrates.org",
+		ID:     "1",
+	}
+	expectedTenantID := "cgrates.org:1"
+	actualTenantID := r.TenantID()
+	if actualTenantID != expectedTenantID {
+		t.Errorf("Expected tenant ID %s, got %s", expectedTenantID, actualTenantID)
+	}
+}
+
+func TestRanking_asRankingSummary(t *testing.T) {
+	rk := &Ranking{
+		Tenant:        "cgrates.org",
+		ID:            "ID1",
+		LastUpdate:    time.Now(),
+		SortedStatIDs: []string{"stat1", "stat2", "stat3"},
+	}
+
+	rkSummary := rk.AsRankingSummary()
+
+	if rkSummary.Tenant != rk.Tenant {
+		t.Errorf("Expected Tenant %s, but got %s", rk.Tenant, rkSummary.Tenant)
+	}
+	if rkSummary.ID != rk.ID {
+		t.Errorf("Expected ID %s, but got %s", rk.ID, rkSummary.ID)
+	}
+	if !rkSummary.LastUpdate.Equal(rk.LastUpdate) {
+		t.Errorf("Expected LastUpdate %v, but got %v", rk.LastUpdate, rkSummary.LastUpdate)
+	}
+	if !reflect.DeepEqual(rkSummary.SortedStatIDs, rk.SortedStatIDs) {
+		t.Errorf("Expected SortedStatIDs %v, but got %v", rk.SortedStatIDs, rkSummary.SortedStatIDs)
+	}
+
+	if &rkSummary.SortedStatIDs == &rk.SortedStatIDs {
+		t.Errorf("Expected SortedStatIDs slice to be copied, not referenced")
+	}
+}
+
+func TestRankingSortStats(t *testing.T) {
+	metrics := map[string]map[string]float64{
+		"stat1": {
+			"metric1": 5.0,
+			"metric2": 10.0,
+		},
+		"stat2": {
+			"metric1": 3.0,
+			"metric2": 12.0,
+		},
+		"stat3": {
+			"metric1": 7.0,
+			"metric2": 8.0,
+		},
+	}
+
+	tests := []struct {
+		name          string
+		sortingType   string
+		sortingParams []string
+		expectedOrder []string
+		expectError   bool
+	}{
+		{
+			name:          "Sort Descending by metric1",
+			sortingType:   MetaDesc,
+			sortingParams: []string{"metric1"},
+			expectedOrder: []string{"stat3", "stat1", "stat2"},
+			expectError:   false,
+		},
+		{
+			name:          "Sort Ascending by metric2",
+			sortingType:   MetaAsc,
+			sortingParams: []string{"metric2"},
+			expectedOrder: []string{"stat3", "stat1", "stat2"},
+			expectError:   false,
+		},
+		{
+			name:          "Unsupported sorting type",
+			sortingType:   "unsupported",
+			sortingParams: []string{"metric1"},
+			expectedOrder: nil,
+			expectError:   true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			sortedStatIDs, err := RankingSortStats(tt.sortingType, tt.sortingParams, metrics)
+			if tt.expectError {
+				if err == nil {
+					t.Errorf("expected error but got nil")
+				}
+				return
+			}
+
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+				return
+			}
+
+			for i, id := range sortedStatIDs {
+				if id != tt.expectedOrder[i] {
+					t.Errorf("expected sorted statID %v at index %d, got %v", tt.expectedOrder[i], i, id)
+				}
+			}
+		})
+	}
+}
+
+func TestRankingMixedOrder(t *testing.T) {
+	statmetrics := map[string]map[string]float64{
+		"Stat1": {"*acc": 13},
+		"Stat6": {"*acc": 10, "*pdd": 700, "*tcc": 121},
+		"Stat2": {"*acc": 14},
+		"Stat5": {"*acc": 10, "*pdd": 700, "*tcc": 120},
+		"Stat3": {"*acc": 12.1, "*pdd": 900},
+		"Stat7": {"*acc": 10, "*pdd": 600, "*tcc": 123},
+		"Stat4": {"*acc": 12.1, "*pdd": 1000},
+	}
+
+	testCases := []struct {
+		name       string
+		sortMetric []string
+		sorter     string
+		statIDs    []string
+		expErr     error
+	}{
+		{
+			name:       "TestSortStatsAsc",
+			sortMetric: []string{"*acc", "*pdd:false", "*tcc"},
+			sorter:     "*asc",
+			statIDs:    []string{"Stat5", "Stat6", "Stat7", "Stat4", "Stat3", "Stat1", "Stat2"},
+		},
+		{
+			name:       "TestSortStatsDesc",
+			sortMetric: []string{"*tcc", "*pdd:false", "*acc"},
+			sorter:     "*desc",
+			statIDs:    []string{"Stat7", "Stat6", "Stat5", "Stat3", "Stat4", "Stat2", "Stat1"},
+		},
+		{
+			name:       "TestSortStatsDesc",
+			sortMetric: []string{"*acc", "*tcc", "*pdd:false"},
+			sorter:     "*desc",
+			statIDs:    []string{"Stat2", "Stat1", "Stat3", "Stat4", "Stat7", "Stat6", "Stat5"},
+		},
+		{
+			name:       "TestSortStatsAsc",
+			sortMetric: []string{"*tcc", "*pdd:false", "*acc"},
+			sorter:     "*asc",
+			statIDs:    []string{"Stat5", "Stat6", "Stat7", "Stat4", "Stat3", "Stat1", "Stat2"},
+		},
+		{
+			name:       "TestSortStatsDesc",
+			sortMetric: []string{"*pdd:false", "*acc", "*tcc"},
+			sorter:     "*desc",
+			statIDs:    []string{"Stat7", "Stat6", "Stat5", "Stat3", "Stat4", "Stat2", "Stat1"},
+		},
+		{
+			name:       "TestSortStatsAsc",
+			sortMetric: []string{"*tcc", "*acc", "*pdd:false"},
+			sorter:     "*asc",
+			statIDs:    []string{"Stat5", "Stat6", "Stat7", "Stat4", "Stat3", "Stat1", "Stat2"},
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			rs, err := newRankingSorter(tc.sorter, tc.sortMetric, statmetrics)
+			if tc.expErr != nil {
+				if err == nil {
+					t.Error("Expected error, got nil")
+				}
+				if tc.expErr.Error() != err.Error() {
+					t.Errorf("Expected error: %v, got: %v", tc.expErr, err)
+				}
+				return
+			}
+			if err != nil {
+				t.Errorf("Unexpected error: %v", err)
+			}
+			if resStatIDs := rs.sortStatIDs(); !reflect.DeepEqual(resStatIDs, tc.statIDs) {
+				t.Errorf("Expecting: %v, received %v", tc.statIDs, resStatIDs)
+			}
+		})
+	}
+
+}
+
+func TestRankingProfileFieldAsString(t *testing.T) {
+	tests := []struct {
+		name    string
+		fldPath []string
+		err     error
+		val     any
+	}{
+		{ID, []string{ID}, nil, "RP1"},
+		{Tenant, []string{Tenant}, nil, "cgrates.org"},
+		{Schedule, []string{Schedule}, nil, "@every 2s"},
+		{StatIDs, []string{StatIDs + "[0]"}, nil, "Stat1"},
+		{StatIDs, []string{StatIDs + "[1]"}, nil, "Stat2"},
+		{MetricIDs, []string{MetricIDs + "[0]"}, nil, "*tcc"},
+		{MetricIDs, []string{MetricIDs + "[1]"}, nil, "*acc"},
+		{Sorting, []string{Sorting}, nil, "*asc"},
+		{Stored, []string{Stored}, nil, false},
+		{SortingParameters, []string{SortingParameters + "[0]"}, nil, "*acc"},
+		{SortingParameters, []string{SortingParameters + "[1]"}, nil, "*pdd:false"},
+		{ThresholdIDs, []string{ThresholdIDs + "[0]"}, nil, "Threshold1"},
+		{ThresholdIDs, []string{ThresholdIDs + "[1]"}, nil, "Threshold2"},
+		{"NonExistingField", []string{"Field1"}, ErrNotFound, nil},
+	}
+	rp := &RankingProfile{
+		Tenant:            "cgrates.org",
+		ID:                "RP1",
+		Schedule:          "@every 2s",
+		StatIDs:           []string{"Stat1", "Stat2"},
+		MetricIDs:         []string{"*tcc", "*acc", "*pdd"},
+		Sorting:           "*asc",
+		SortingParameters: []string{"*acc", "*pdd:false"},
+		ThresholdIDs:      []string{"Threshold1", "Threshold2"},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			val, err := rp.FieldAsInterface(tc.fldPath)
+			if tc.err != nil {
+				if err == nil {
+					t.Error("expect to receive an error")
+				}
+				if tc.err != err {
+					t.Errorf("expected %v,received %v", tc.err, err)
+				}
+				return
+			}
+			if err != nil {
+				t.Errorf("unexpected error %v", err)
+			}
+			if val != tc.val {
+				t.Errorf("expected %v,received %v", tc.val, val)
+			}
+		})
+	}
+}
+
+func TestNewRankingSorter(t *testing.T) {
+	Metrics := map[string]map[string]float64{
+		"STATS1": {"*acc": 12.1, "*tcc": 24.2},
+		"STATS2": {"*acc": 12.1, "*tcc": 24.3},
+		"STATS3": {"*acc": 10.1, "*tcc": 25.3},
+		"STATS4": {"*tcc": 26.3},
+	}
+
+	tests := []struct {
+		sortingType      string
+		sortingParams    []string
+		expectErr        bool
+		expectSorterType string
+	}{
+		{
+			sortingType:      MetaAsc,
+			sortingParams:    []string{"*acc"},
+			expectErr:        false,
+			expectSorterType: "RankingAscSorter",
+		},
+		{
+			sortingType:      MetaDesc,
+			sortingParams:    []string{"*tcc"},
+			expectErr:        false,
+			expectSorterType: "RankingDescSorter",
+		},
+		{
+			sortingType:      "unsupported",
+			sortingParams:    []string{"*tcc"},
+			expectErr:        true,
+			expectSorterType: "",
+		},
+	}
+
+	for _, test := range tests {
+		rkSorter, err := newRankingSorter(test.sortingType, test.sortingParams, Metrics)
+
+		if test.expectErr {
+			if err == nil {
+				t.Errorf("Expected an error for sorting type %q, but got none", test.sortingType)
+			}
+		} else {
+			if err != nil {
+				t.Errorf("Did not expect an error for sorting type %q, but got: %v", test.sortingType, err)
+			}
+			switch test.sortingType {
+			case MetaAsc:
+				if _, ok := rkSorter.(*rankingAscSorter); !ok {
+					t.Errorf("Expected sorter type 'rankingAscSorter', but got %T", rkSorter)
+				}
+			case MetaDesc:
+				if _, ok := rkSorter.(*rankingDescSorter); !ok {
+					t.Errorf("Expected sorter type 'rankingDescSorter', but got %T", rkSorter)
+				}
+			}
+		}
+	}
+}
+
+func TestRankingProfileSet(t *testing.T) {
+	tests := []struct {
+		name        string
+		path        []string
+		val         any
+		expectedErr error
+		expectedRP  RankingProfile
+	}{
+		{
+			name:        "Set Tenant",
+			path:        []string{Tenant},
+			val:         "cgrates.org",
+			expectedErr: nil,
+			expectedRP:  RankingProfile{Tenant: "cgrates.org"},
+		},
+		{
+			name:        "Set ID",
+			path:        []string{ID},
+			val:         "profile1",
+			expectedErr: nil,
+			expectedRP:  RankingProfile{ID: "profile1"},
+		},
+		{
+			name:        "Set Schedule",
+			path:        []string{Schedule},
+			val:         "0 0 * * *",
+			expectedErr: nil,
+			expectedRP:  RankingProfile{Schedule: "0 0 * * *"},
+		},
+		{
+			name:        "Set StatIDs",
+			path:        []string{StatIDs},
+			val:         []string{"stat1", "stat2"},
+			expectedErr: nil,
+			expectedRP:  RankingProfile{StatIDs: []string{"stat1", "stat2"}},
+		},
+		{
+			name:        "Set MetricIDs",
+			path:        []string{MetricIDs},
+			val:         []string{"metric1", "metric2"},
+			expectedErr: nil,
+			expectedRP:  RankingProfile{MetricIDs: []string{"metric1", "metric2"}},
+		},
+		{
+			name:        "Set Sorting",
+			path:        []string{Sorting},
+			val:         "asc",
+			expectedErr: nil,
+			expectedRP:  RankingProfile{Sorting: "asc"},
+		},
+		{
+			name:        "Set SortingParameters",
+			path:        []string{SortingParameters},
+			val:         []string{"param1", "param2"},
+			expectedErr: nil,
+			expectedRP:  RankingProfile{SortingParameters: []string{"param1", "param2"}},
+		},
+		{
+			name:        "Set Stored",
+			path:        []string{Stored},
+			val:         true,
+			expectedErr: nil,
+			expectedRP:  RankingProfile{Stored: true},
+		},
+		{
+			name:        "Set ThresholdIDs",
+			path:        []string{ThresholdIDs},
+			val:         []string{"threshold1", "threshold2"},
+			expectedErr: nil,
+			expectedRP:  RankingProfile{ThresholdIDs: []string{"threshold1", "threshold2"}},
+		},
+		{
+			name:        "Wrong path",
+			path:        []string{"wrongpath"},
+			val:         "value",
+			expectedErr: ErrWrongPath,
+			expectedRP:  RankingProfile{},
+		},
+		{
+			name:        "Empty path",
+			path:        []string{},
+			val:         "value",
+			expectedErr: ErrWrongPath,
+			expectedRP:  RankingProfile{},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			rp := &RankingProfile{}
+			err := rp.Set(tt.path, tt.val, false)
+
+			if err != tt.expectedErr {
+				t.Errorf("Test %s failed: expected error %v, got %v", tt.name, tt.expectedErr, err)
+			}
+
+			if rp.Tenant != tt.expectedRP.Tenant {
+				t.Errorf("Test %s failed: expected Tenant %s, got %s", tt.name, tt.expectedRP.Tenant, rp.Tenant)
+			}
+			if rp.ID != tt.expectedRP.ID {
+				t.Errorf("Test %s failed: expected ID %s, got %s", tt.name, tt.expectedRP.ID, rp.ID)
+			}
+			if rp.Schedule != tt.expectedRP.Schedule {
+				t.Errorf("Test %s failed: expected Schedule %s, got %s", tt.name, tt.expectedRP.Schedule, rp.Schedule)
+			}
+
+			if !reflect.DeepEqual(rp.StatIDs, tt.expectedRP.StatIDs) {
+				t.Errorf("Test %s failed: expected StatIDs %v, got %v", tt.name, tt.expectedRP.StatIDs, rp.StatIDs)
+			}
+			if !reflect.DeepEqual(rp.MetricIDs, tt.expectedRP.MetricIDs) {
+				t.Errorf("Test %s failed: expected MetricIDs %v, got %v", tt.name, tt.expectedRP.MetricIDs, rp.MetricIDs)
+			}
+			if !reflect.DeepEqual(rp.SortingParameters, tt.expectedRP.SortingParameters) {
+				t.Errorf("Test %s failed: expected SortingParameters %v, got %v", tt.name, tt.expectedRP.SortingParameters, rp.SortingParameters)
+			}
+			if !reflect.DeepEqual(rp.ThresholdIDs, tt.expectedRP.ThresholdIDs) {
+				t.Errorf("Test %s failed: expected ThresholdIDs %v, got %v", tt.name, tt.expectedRP.ThresholdIDs, rp.ThresholdIDs)
+			}
+			if rp.Sorting != tt.expectedRP.Sorting {
+				t.Errorf("Test %s failed: expected Sorting %s, got %s", tt.name, tt.expectedRP.Sorting, rp.Sorting)
+			}
+			if rp.Stored != tt.expectedRP.Stored {
+				t.Errorf("Test %s failed: expected Stored %v, got %v", tt.name, tt.expectedRP.Stored, rp.Stored)
+			}
+		})
+	}
+}
+
+func TestRankingProfileStringJson(t *testing.T) {
+	tests := []struct {
+		name         string
+		rp           RankingProfile
+		expectedJSON string
+	}{
+		{
+			name: "Valid RankingProfile",
+			rp: RankingProfile{
+				Tenant:            "cgrates.org",
+				ID:                "profile1",
+				Schedule:          "0 0 * * *",
+				StatIDs:           []string{"stat1", "stat2"},
+				MetricIDs:         []string{"metric1", "metric2"},
+				Sorting:           "asc",
+				SortingParameters: []string{"param1", "param2"},
+				Stored:            true,
+				ThresholdIDs:      []string{"threshold1"},
+			},
+			expectedJSON: `{"Tenant":"cgrates.org","ID":"profile1","Schedule":"0 0 * * *","StatIDs":["stat1","stat2"],"MetricIDs":["metric1","metric2"],"Sorting":"asc","SortingParameters":["param1","param2"],"Stored":true,"ThresholdIDs":["threshold1"]}`,
+		},
+		{
+			name: "Empty RankingProfile",
+			rp: RankingProfile{
+				Tenant:            "",
+				ID:                "",
+				Schedule:          "",
+				StatIDs:           []string{},
+				MetricIDs:         []string{},
+				Sorting:           "",
+				SortingParameters: []string{},
+				Stored:            false,
+				ThresholdIDs:      []string{},
+			},
+			expectedJSON: `{"Tenant":"","ID":"","Schedule":"","StatIDs":[],"MetricIDs":[],"Sorting":"","SortingParameters":[],"Stored":false,"ThresholdIDs":[]}`,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := tt.rp.String()
+
+			var resultMap map[string]any
+			err := json.Unmarshal([]byte(result), &resultMap)
+			if err != nil {
+				t.Errorf("Error unmarshalling result: %v", err)
+			}
+
+			expectedMap := map[string]any{}
+			err = json.Unmarshal([]byte(tt.expectedJSON), &expectedMap)
+			if err != nil {
+				t.Errorf("Error unmarshalling expected JSON: %v", err)
+			}
+
+			for key, value1 := range resultMap {
+				if value2, exists := expectedMap[key]; exists {
+					if value1Slice, ok1 := value1.([]any); ok1 {
+						if value2Slice, ok2 := value2.([]any); ok2 {
+							if len(value1Slice) != len(value2Slice) {
+								t.Errorf("Test %s failed: slice length mismatch for key %s", tt.name, key)
+							}
+							for i, v1 := range value1Slice {
+								if v1 != value2Slice[i] {
+									t.Errorf("Test %s failed: slice mismatch for key %s at index %d", tt.name, key, i)
+								}
+							}
+						}
+					} else {
+						if value1 != value2 {
+							t.Errorf("Test %s failed: expected %v for key %s, got %v", tt.name, value2, key, value1)
+						}
+					}
+				} else {
+					t.Errorf("Test %s failed: key %s not found in expected result", tt.name, key)
+				}
+			}
+		})
+	}
+}
+
+func TestTpRankingProfileFieldAsString(t *testing.T) {
+	tests := []struct {
+		name      string
+		profile   RankingProfile
+		fldPath   []string
+		expected  string
+		expectErr bool
+	}{
+		{
+			name: "Valid field path",
+			profile: RankingProfile{
+				Tenant:            "cgrates.org",
+				ID:                "profile1",
+				Schedule:          "0 0 * * *",
+				StatIDs:           []string{"stat1", "stat2"},
+				MetricIDs:         []string{"metric1", "metric2"},
+				SortingParameters: []string{"param1", "param2"},
+				ThresholdIDs:      []string{"threshold1", "threshold2"},
+			},
+			fldPath:   []string{"Tenant"},
+			expected:  "cgrates.org",
+			expectErr: false,
+		},
+		{
+			name: "Invalid field path",
+			profile: RankingProfile{
+				Tenant:            "cgrates.org",
+				ID:                "profile1",
+				Schedule:          "0 0 * * *",
+				StatIDs:           []string{"stat1", "stat2"},
+				MetricIDs:         []string{"metric1", "metric2"},
+				SortingParameters: []string{"param1", "param2"},
+				ThresholdIDs:      []string{"threshold1", "threshold2"},
+			},
+			fldPath:   []string{"NonExistentField"},
+			expected:  "",
+			expectErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result, err := tt.profile.FieldAsString(tt.fldPath)
+
+			if tt.expectErr && err == nil {
+				t.Errorf("Expected an error for test %s, but got none", tt.name)
+			}
+			if !tt.expectErr && err != nil {
+				t.Errorf("Unexpected error for test %s: %v", tt.name, err)
+			}
+
+			if result != tt.expected {
+				t.Errorf("Test %s failed: expected %v, got %v", tt.name, tt.expected, result)
+			}
+		})
+	}
+}