uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

AsStoredCdr -> AsCDR

Browse Source
This commit is contained in:
TeoV
2017-11-14 12:46:02 +02:00
committed by Dan Christian Bogos
parent 09d517d984
commit 2a6f929d19
23 changed files with 44 additions and 44 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
apier/v1/auth.go
View File

@@ -56,7 +56,7 @@ func (self *ApierV1) GetMaxUsage(usageRecord engine.UsageRecord, maxUsage *float
if usageRecord.Usage == "" {
usageRecord.Usage = strconv.FormatFloat(self.Config.MaxCallDuration.Seconds(), 'f', -1, 64)
}
storedCdr, err := usageRecord.AsStoredCdr(self.Config.DefaultTimezone)
storedCdr, err := usageRecord.AsCDR(self.Config.DefaultTimezone)
if err != nil {
return utils.NewErrServerError(err)
}

4
engine/cdr.go
View File

@@ -285,7 +285,7 @@ func (cdr *CDR) FieldsAsString(rsrFlds utils.RSRFields) string {
return fldVal
}
func (cdr *CDR) AsStoredCdr(timezone string) *CDR {
func (cdr *CDR) AsCDR(timezone string) *CDR {
return cdr
}
@@ -913,7 +913,7 @@ type UsageRecord struct {
ExtraFields map[string]string
}
func (self *UsageRecord) AsStoredCdr(timezone string) (*CDR, error) {
func (self *UsageRecord) AsCDR(timezone string) (*CDR, error) {
var err error
cdr := &CDR{CGRID: self.GetId(), ToR: self.ToR, RequestType: self.RequestType, Direction: self.Direction,
Tenant: self.Tenant, Category: self.Category, Account: self.Account, Subject: self.Subject, Destination: self.Destination}

2
engine/cdr_test.go
View File

@@ -461,7 +461,7 @@ func TesUsageReqAsCDR(t *testing.T) {
eStorCdr := &CDR{ToR: utils.VOICE, RequestType: utils.META_RATED, Direction: "*out",
Tenant: "cgrates.org", Category: "call", Account: "1001", Subject: "1001", Destination: "1002",
SetupTime: time.Date(2013, 11, 7, 8, 42, 20, 0, time.UTC), AnswerTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), Usage: time.Duration(10)}
if CDR, err := setupReq.AsStoredCdr(""); err != nil {
if CDR, err := setupReq.AsCDR(""); err != nil {
t.Error(err)
} else if !reflect.DeepEqual(eStorCdr, CDR) {
t.Errorf("Expected: %+v, received: %+v", eStorCdr, CDR)

4
engine/cdrs.go
View File

@@ -51,7 +51,7 @@ func cgrCdrHandler(w http.ResponseWriter, r *http.Request) {
utils.Logger.Err(fmt.Sprintf("<CDRS> Could not create CDR entry: %s", err.Error()))
return
}
if err := cdrServer.processCdr(cgrCdr.AsStoredCdr(cdrServer.cgrCfg.DefaultTimezone)); err != nil {
if err := cdrServer.processCdr(cgrCdr.AsCDR(cdrServer.cgrCfg.DefaultTimezone)); err != nil {
utils.Logger.Err(fmt.Sprintf("<CDRS> Errors when storing CDR entry: %s", err.Error()))
}
}
@@ -64,7 +64,7 @@ func fsCdrHandler(w http.ResponseWriter, r *http.Request) {
utils.Logger.Err(fmt.Sprintf("<CDRS> Could not create CDR entry: %s", err.Error()))
return
}
if err := cdrServer.processCdr(fsCdr.AsStoredCdr(cdrServer.Timezone())); err != nil {
if err := cdrServer.processCdr(fsCdr.AsCDR(cdrServer.Timezone())); err != nil {
utils.Logger.Err(fmt.Sprintf("<CDRS> Errors when storing CDR entry: %s", err.Error()))
}
}

2
engine/cgrcdr.go
View File

@@ -58,7 +58,7 @@ func (cgrCdr CgrCdr) getExtraFields() map[string]string {
return extraFields
}
func (cgrCdr CgrCdr) AsStoredCdr(timezone string) *CDR {
func (cgrCdr CgrCdr) AsCDR(timezone string) *CDR {
storCdr := new(CDR)
storCdr.CGRID = cgrCdr.getCGRID(timezone)
storCdr.ToR = cgrCdr[utils.TOR]

4
engine/cgrcdr_test.go
View File

@@ -46,7 +46,7 @@ func TestCgrCdrAsCDR(t *testing.T) {
Destination: cgrCdr[utils.DESTINATION], SetupTime: time.Date(2013, 11, 7, 8, 42, 20, 0, time.UTC), AnswerTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC),
Usage: time.Duration(10) * time.Second, Supplier: "SUPPL1",
ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: -1}
if CDR := cgrCdr.AsStoredCdr(""); !reflect.DeepEqual(expctRtCdr, CDR) {
if CDR := cgrCdr.AsCDR(""); !reflect.DeepEqual(expctRtCdr, CDR) {
t.Errorf("Expecting %v, received: %v", expctRtCdr, CDR)
}
}
@@ -80,7 +80,7 @@ func TestReplicatedCgrCdrAsCDR(t *testing.T) {
Cost: 0.12,
Rated: true,
}
if CDR := cgrCdr.AsStoredCdr(""); !reflect.DeepEqual(expctRtCdr, CDR) {
if CDR := cgrCdr.AsCDR(""); !reflect.DeepEqual(expctRtCdr, CDR) {
t.Errorf("Expecting %v, received: %v", expctRtCdr, CDR)
}
}

2
engine/event.go
View File

@@ -47,7 +47,7 @@ type Event interface {
GetExtraFields() map[string]string
MissingParameter(string) bool
ParseEventValue(*utils.RSRField, string) string
AsStoredCdr(timezone string) *CDR
AsCDR(timezone string) *CDR
String() string
AsEvent(string) Event
ComputeLcr() bool

2
engine/fscdr.go
View File

@@ -123,7 +123,7 @@ func (fsCdr FSCdr) searchExtraField(field string, body map[string]interface{}) (
return
}
func (fsCdr FSCdr) AsStoredCdr(timezone string) *CDR {
func (fsCdr FSCdr) AsCDR(timezone string) *CDR {
storCdr := new(CDR)
storCdr.CGRID = fsCdr.getCGRID(timezone)
storCdr.ToR = utils.VOICE

2
engine/fscdr_test.go
View File

@@ -57,7 +57,7 @@ func TestCDRFields(t *testing.T) {
OriginHost: "127.0.0.1", Source: "freeswitch_json", Direction: utils.OUT, Category: "call", RequestType: utils.META_PREPAID, Tenant: "cgrates.org", Account: "1001", Subject: "1001",
Destination: "1003", SetupTime: setupTime, PDD: time.Duration(28) * time.Millisecond, AnswerTime: answerTime, Usage: time.Duration(66) * time.Second, Supplier: "supplier1",
DisconnectCause: "NORMAL_CLEARING", ExtraFields: map[string]string{"sip_user_agent": "PJSUA v2.3 Linux-3.2.0.4/x86_64/glibc-2.13"}, Cost: -1}
if CDR := fsCdr.AsStoredCdr(""); !reflect.DeepEqual(expctCDR, CDR) {
if CDR := fsCdr.AsCDR(""); !reflect.DeepEqual(expctCDR, CDR) {
t.Errorf("Expecting: %v, received: %v", expctCDR, CDR)
}
}

2
engine/rawcdr.go
View File

@@ -20,5 +20,5 @@ package engine
// RawCDR is the original CDR received from external sources (eg: FreeSWITCH)
type RawCdr interface {
AsStoredCdr(string) *CDR // Convert the inbound Cdr into internally used one, CgrCdr
AsCDR(string) *CDR // Convert the inbound Cdr into internally used one, CgrCdr
}

16
general_tests/fsevcorelate_test.go
View File

@@ -221,11 +221,11 @@ func TestEvCorelate(t *testing.T) {
cdrEv, err := engine.NewFSCdr(jsonCdr, cfg)
if err != nil {
t.Errorf("Error loading cdr: %v", err.Error())
} else if cdrEv.AsStoredCdr("").OriginID != "86cfd6e2-dbda-45a3-b59d-f683ec368e8b" {
t.Error("Unexpected acntId received", cdrEv.AsStoredCdr("").OriginID)
} else if cdrEv.AsCDR("").OriginID != "86cfd6e2-dbda-45a3-b59d-f683ec368e8b" {
t.Error("Unexpected acntId received", cdrEv.AsCDR("").OriginID)
}
if answerEv.GetCgrId("") != cdrEv.AsStoredCdr("").CGRID {
t.Error("CGRIDs do not match", answerEv.GetCgrId(""), cdrEv.AsStoredCdr("").CGRID)
if answerEv.GetCgrId("") != cdrEv.AsCDR("").CGRID {
t.Error("CGRIDs do not match", answerEv.GetCgrId(""), cdrEv.AsCDR("").CGRID)
}
}
@@ -549,14 +549,14 @@ func TestEvCdrCorelate(t *testing.T) {
}
cfg, _ := config.NewDefaultCGRConfig()
config.SetCgrConfig(cfg)
evStoredCdr := hangupEv.AsStoredCdr("")
evStoredCdr := hangupEv.AsCDR("")
cdrEv, err := engine.NewFSCdr(jsonCdr2, cfg)
if err != nil {
t.Errorf("Error loading cdr: %v", err.Error())
} else if cdrEv.AsStoredCdr("").OriginID != "e3133bf7-dcde-4daf-9663-9a79ffcef5ad" {
t.Error("Unexpected acntId received", cdrEv.AsStoredCdr("").OriginID)
} else if cdrEv.AsCDR("").OriginID != "e3133bf7-dcde-4daf-9663-9a79ffcef5ad" {
t.Error("Unexpected acntId received", cdrEv.AsCDR("").OriginID)
}
jsnStoredCdr := cdrEv.AsStoredCdr("")
jsnStoredCdr := cdrEv.AsCDR("")
if evStoredCdr.CGRID != jsnStoredCdr.CGRID {
t.Errorf("evStoredCdr.CGRID: %s, jsnStoredCdr.CGRID: %s", evStoredCdr.CGRID, jsnStoredCdr.CGRID)
}

2
sessionmanager/fsevent.go
View File

@@ -339,7 +339,7 @@ func (fsev FSEvent) PassesFieldFilter(fieldFilter *utils.RSRField) (bool, string
}
*/
func (fsev FSEvent) AsStoredCdr(timezone string) *engine.CDR {
func (fsev FSEvent) AsCDR(timezone string) *engine.CDR {
storCdr := new(engine.CDR)
storCdr.CGRID = fsev.GetCgrId(timezone)
storCdr.ToR = utils.VOICE

4
sessionmanager/fsevent_test.go
View File

@@ -628,7 +628,7 @@ Caller-Username: 04021292812`
}
*/
func TestFsEvAsStoredCdr(t *testing.T) {
func TestFsEvAsCDR(t *testing.T) {
cfg, _ := config.NewDefaultCGRConfig()
config.SetCgrConfig(cfg)
ev := new(FSEvent).AsEvent(hangupEv)
@@ -640,7 +640,7 @@ func TestFsEvAsStoredCdr(t *testing.T) {
Destination: "1003", SetupTime: setupTime, AnswerTime: aTime,
Usage: time.Duration(66) * time.Second, PDD: time.Duration(28) * time.Millisecond, Supplier: "supplier1",
DisconnectCause: "NORMAL_CLEARING", ExtraFields: make(map[string]string), Cost: -1}
if storedCdr := ev.AsStoredCdr(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
if storedCdr := ev.AsCDR(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
t.Errorf("Expecting: %+v, received: %+v", eStoredCdr, storedCdr)
}
}

4
sessionmanager/fssessionmanager.go
View File

@@ -163,7 +163,7 @@ func (sm *FSSessionManager) onChannelPark(ev engine.Event, connId string) {
if ev.GetReqType(utils.META_DEFAULT) != utils.META_NONE { // Do not process this request
var maxCallDuration float64 // This will be the maximum duration this channel will be allowed to last
if err := sm.rater.Call("Responder.GetDerivedMaxSessionTime",
ev.AsStoredCdr(config.CgrConfig().DefaultTimezone), &maxCallDuration); err != nil {
ev.AsCDR(config.CgrConfig().DefaultTimezone), &maxCallDuration); err != nil {
utils.Logger.Err(fmt.Sprintf("<SM-FreeSWITCH> Could not get max session time for %s, error: %s",
ev.GetUUID(), err.Error()))
}
@@ -276,7 +276,7 @@ func (sm *FSSessionManager) onChannelHangupComplete(ev engine.Event) {
}
}
if sm.cfg.CreateCdr {
sm.ProcessCdr(ev.AsStoredCdr(config.CgrConfig().DefaultTimezone))
sm.ProcessCdr(ev.AsCDR(config.CgrConfig().DefaultTimezone))
}
var reply string
attrRU := utils.ArgRSv1ResourceUsage{

4
sessionmanager/kamailiosm.go
View File

@@ -110,7 +110,7 @@ func (self *KamailioSessionManager) onCgrAuth(evData []byte, connId string) {
var remainingDuration float64
var errReply error
if errReply = self.rater.Call("Responder.GetDerivedMaxSessionTime",
kev.AsStoredCdr(self.timezone), &remainingDuration); errReply != nil {
kev.AsCDR(self.timezone), &remainingDuration); errReply != nil {
utils.Logger.Err(fmt.Sprintf("<SM-Kamailio> Could not get max session time, error: %s", errReply.Error()))
}
var supplStr string
@@ -205,7 +205,7 @@ func (self *KamailioSessionManager) onCallEnd(evData []byte, connId string) {
if kev.MissingParameter(self.timezone) {
utils.Logger.Err(fmt.Sprintf("<SM-Kamailio> Mandatory IE missing out of event: %+v", kev))
}
go self.ProcessCdr(kev.AsStoredCdr(self.Timezone()))
go self.ProcessCdr(kev.AsCDR(self.Timezone()))
if self.rlS != nil { // Release RLs resource
go func() {
ev, err := kev.AsMapStringIface()

2
sessionmanager/kamevent.go
View File

@@ -320,7 +320,7 @@ func (kev KamEvent) PassesFieldFilter(*utils.RSRField) (bool, string) {
return false, ""
}
func (kev KamEvent) AsStoredCdr(timezone string) *engine.CDR {
func (kev KamEvent) AsCDR(timezone string) *engine.CDR {
storCdr := new(engine.CDR)
storCdr.CGRID = kev.GetCgrId(timezone)
storCdr.ToR = utils.VOICE

2
sessionmanager/osipsevent.go
View File

@@ -264,7 +264,7 @@ func (osipsev *OsipsEvent) DialogId() string {
return osipsev.osipsEvent.AttrValues[OSIPS_DIALOG_ID]
}
func (osipsEv *OsipsEvent) AsStoredCdr(timezone string) *engine.CDR {
func (osipsEv *OsipsEvent) AsCDR(timezone string) *engine.CDR {
storCdr := new(engine.CDR)
storCdr.CGRID = osipsEv.GetCgrId(timezone)
storCdr.ToR = utils.VOICE

6
sessionmanager/osipsevent_test.go
View File

@@ -139,7 +139,7 @@ func TestOsipsEventMissingParameter(t *testing.T) {
}
}
func TestOsipsEventAsStoredCdr(t *testing.T) {
func TestOsipsEventAsCDR(t *testing.T) {
setupTime, _ := utils.ParseTimeDetectLayout("1406370492", "")
answerTime, _ := utils.ParseTimeDetectLayout("1406370499", "")
eStoredCdr := &engine.CDR{CGRID: utils.Sha1("ODVkMDI2Mzc2MDY5N2EzODhjNTAzNTdlODhiZjRlYWQ", setupTime.UTC().String()),
@@ -148,7 +148,7 @@ func TestOsipsEventAsStoredCdr(t *testing.T) {
Direction: utils.OUT, Tenant: "itsyscom.com", Category: "call", Account: "dan", Subject: "dan",
Destination: "+4986517174963", SetupTime: setupTime, AnswerTime: answerTime,
Usage: time.Duration(20) * time.Second, PDD: time.Duration(3) * time.Second, Supplier: "supplier3", DisconnectCause: "200", ExtraFields: map[string]string{"extra1": "val1", "extra2": "val2"}, Cost: -1}
if storedCdr := osipsEv.AsStoredCdr(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
if storedCdr := osipsEv.AsCDR(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
t.Errorf("Expecting: %+v, received: %+v", eStoredCdr, storedCdr)
}
}
@@ -166,7 +166,7 @@ func TestOsipsAccMissedToStoredCdr(t *testing.T) {
RequestType: utils.META_PSEUDOPREPAID, Direction: utils.OUT, Tenant: "cgrates.org", Category: "call", Account: "1001", Subject: "1001", Supplier: "supplier1",
DisconnectCause: "404", Destination: "1002", SetupTime: setupTime, AnswerTime: setupTime,
Usage: time.Duration(0), ExtraFields: map[string]string{"extra1": "val1", "extra2": "val2"}, Cost: -1}
if storedCdr := osipsEv.AsStoredCdr(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
if storedCdr := osipsEv.AsCDR(""); !reflect.DeepEqual(eStoredCdr, storedCdr) {
t.Errorf("Expecting: %+v, received: %+v", eStoredCdr, storedCdr)
}

4
sessionmanager/osipssm.go
View File

@@ -232,7 +232,7 @@ func (osm *OsipsSessionManager) onOpensipsStart(cdrDagram *osipsdagram.OsipsEven
// Triggered by CDR event
func (osm *OsipsSessionManager) onCdr(cdrDagram *osipsdagram.OsipsEvent) {
osipsEv, _ := NewOsipsEvent(cdrDagram)
if err := osm.ProcessCdr(osipsEv.AsStoredCdr(osm.timezone)); err != nil {
if err := osm.ProcessCdr(osipsEv.AsCDR(osm.timezone)); err != nil {
utils.Logger.Err(fmt.Sprintf("<SM-OpenSIPS> Failed processing CDR, cgrid: %s, accid: %s, error: <%s>", osipsEv.GetCgrId(osm.timezone), osipsEv.GetUUID(), err.Error()))
}
}
@@ -334,7 +334,7 @@ func (osm *OsipsSessionManager) processCdrStop(osipsEv *OsipsEvent) error {
if err := osipsEvStart.updateDurationFromEvent(osipsEv); err != nil {
return err
}
return osm.ProcessCdr(osipsEvStart.AsStoredCdr(osm.timezone))
return osm.ProcessCdr(osipsEvStart.AsCDR(osm.timezone))
}
func (osm *OsipsSessionManager) Sessions() []*Session {

2
sessionmanager/session.go
View File

@@ -59,7 +59,7 @@ func NewSession(ev engine.Event, connId string, sm SessionManager) *Session {
sessionManager: sm,
connId: connId,
}
if err := sm.Rater().Call("Responder.GetSessionRuns", ev.AsStoredCdr(s.sessionManager.Timezone()), &s.sessionRuns); err != nil || len(s.sessionRuns) == 0 {
if err := sm.Rater().Call("Responder.GetSessionRuns", ev.AsCDR(s.sessionManager.Timezone()), &s.sessionRuns); err != nil || len(s.sessionRuns) == 0 {
return nil
}
for runIdx := range s.sessionRuns {

2
sessionmanager/smg_event.go
View File

@@ -416,7 +416,7 @@ func (self SMGenericEvent) PassesFieldFilter(*utils.RSRField) (bool, string) {
return true, ""
}
func (self SMGenericEvent) AsStoredCdr(cfg *config.CGRConfig, timezone string) *engine.CDR {
func (self SMGenericEvent) AsCDR(cfg *config.CGRConfig, timezone string) *engine.CDR {
storCdr := engine.NewCDRWithDefaults(cfg)
storCdr.CGRID = self.GetCGRID(utils.META_DEFAULT)
storCdr.ToR = utils.FirstNonEmpty(self.GetTOR(utils.META_DEFAULT), storCdr.ToR) // Keep default if none in the event

4
sessionmanager/smg_event_test.go
View File

@@ -150,7 +150,7 @@ func TestSMGenericEventGetSessionTTL(t *testing.T) {
}
}
func TestSMGenericEventAsStoredCdr(t *testing.T) {
func TestSMGenericEventAsCDR(t *testing.T) {
smGev := SMGenericEvent{}
smGev[utils.EVENT_NAME] = "TEST_EVENT"
smGev[utils.TOR] = utils.SMS
@@ -177,7 +177,7 @@ func TestSMGenericEventAsStoredCdr(t *testing.T) {
Destination: "+4986517174963", SetupTime: time.Date(2015, 11, 9, 14, 21, 24, 0, time.UTC), AnswerTime: time.Date(2015, 11, 9, 14, 22, 2, 0, time.UTC),
Usage: time.Duration(83) * time.Second, PDD: time.Duration(300) * time.Millisecond, Supplier: "supplier1", DisconnectCause: "NORMAL_DISCONNECT",
ExtraFields: map[string]string{"Extra1": "Value1", "Extra2": "5"}, Cost: -1}
if storedCdr := smGev.AsStoredCdr(cfg, "UTC"); !reflect.DeepEqual(eStoredCdr, storedCdr) {
if storedCdr := smGev.AsCDR(cfg, "UTC"); !reflect.DeepEqual(eStoredCdr, storedCdr) {
t.Errorf("Expecting: %+v, received: %+v", eStoredCdr, storedCdr)
}
}

10
sessionmanager/smgeneric.go
View File

@@ -185,7 +185,7 @@ func (smg *SMGeneric) ttlTerminate(s *SMGSession, tmtr *smgSessionTerminator) {
s.debit(debitUsage, tmtr.ttlLastUsed)
}
smg.sessionEnd(s.CGRID, s.TotalUsage)
cdr := s.EventStart.AsStoredCdr(smg.cgrCfg, smg.Timezone)
cdr := s.EventStart.AsCDR(smg.cgrCfg, smg.Timezone)
cdr.Usage = s.TotalUsage
var reply string
smg.cdrsrv.Call("CdrsV1.ProcessCDR", cdr, &reply)
@@ -368,7 +368,7 @@ func (smg *SMGeneric) sessionStart(evStart SMGenericEvent, clntConn rpcclient.Rp
return nil, nil // ToDo: handle here also debits
}
var sessionRuns []*engine.SessionRun
if err := smg.rals.Call("Responder.GetSessionRuns", evStart.AsStoredCdr(smg.cgrCfg, smg.Timezone), &sessionRuns); err != nil {
if err := smg.rals.Call("Responder.GetSessionRuns", evStart.AsCDR(smg.cgrCfg, smg.Timezone), &sessionRuns); err != nil {
return nil, err
} else if len(sessionRuns) == 0 {
return nil, nil
@@ -655,7 +655,7 @@ func (smg *SMGeneric) GetMaxUsage(gev SMGenericEvent) (maxUsage time.Duration, e
}
defer smg.responseCache.Cache(cacheKey, &cache.CacheItem{Value: maxUsage, Err: err})
gev[utils.EVENT_NAME] = utils.CGR_AUTHORIZATION
storedCdr := gev.AsStoredCdr(config.CgrConfig(), smg.Timezone)
storedCdr := gev.AsCDR(config.CgrConfig(), smg.Timezone)
var maxDur float64
if err = smg.rals.Call("Responder.GetDerivedMaxSessionTime", storedCdr, &maxDur); err != nil {
return
@@ -857,7 +857,7 @@ func (smg *SMGeneric) ChargeEvent(gev SMGenericEvent) (maxUsage time.Duration, e
}
defer smg.responseCache.Cache(cacheKey, &cache.CacheItem{Value: maxUsage, Err: err})
var sessionRuns []*engine.SessionRun
if err = smg.rals.Call("Responder.GetSessionRuns", gev.AsStoredCdr(smg.cgrCfg, smg.Timezone), &sessionRuns); err != nil {
if err = smg.rals.Call("Responder.GetSessionRuns", gev.AsCDR(smg.cgrCfg, smg.Timezone), &sessionRuns); err != nil {
return
} else if len(sessionRuns) == 0 {
return
@@ -961,7 +961,7 @@ func (smg *SMGeneric) ProcessCDR(gev SMGenericEvent) (err error) {
}
defer smg.responseCache.Cache(cacheKey, &cache.CacheItem{Err: err})
var reply string
if err = smg.cdrsrv.Call("CdrsV1.ProcessCDR", gev.AsStoredCdr(smg.cgrCfg, smg.Timezone), &reply); err != nil {
if err = smg.cdrsrv.Call("CdrsV1.ProcessCDR", gev.AsCDR(smg.cgrCfg, smg.Timezone), &reply); err != nil {
return
}
return