StoredCdr.Duration -> StoredCdr.Usage

apier/apier_local_test.go

@@ -1616,7 +1616,7 @@ func TestLocalGetDataCost(t *testing.T) {
 	var rply *engine.DataCost
 	if err := rater.Call("ApierV1.GetDataCost", attrs, &rply); err != nil {
 		t.Error("Unexpected nil error received: ", err.Error())
-	} else if rply.Cost != 128.03 {
+	} else if rply.Cost != 128.0240 {
 		t.Errorf("Unexpected cost received: %f", rply.Cost)
 	}
 }

cdrc/cdrc.go

@@ -1,6 +1,6 @@
 /*
-Rating system designed to be used in VoIP Carriers World
-Copyright (C) 2013 ITsysCOM
+Real-time Charging System for Telecom & ISP environments
+Copyright (C) 2012-2014 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
@@ -113,8 +113,8 @@ func (self *Cdrc) recordForkCdr(record []string) (*utils.StoredCdr, error) {
 			if storedCdr.AnswerTime, err = utils.ParseTimeDetectLayout(fieldVal); err != nil {
 				return nil, fmt.Errorf("Cannot parse answer time field, err: %s", err.Error())
 			}
-		case utils.DURATION:
-			if storedCdr.Duration, err = utils.ParseDurationWithSecs(fieldVal); err != nil {
+		case utils.USAGE:
+			if storedCdr.Usage, err = utils.ParseDurationWithSecs(fieldVal); err != nil {
 				return nil, fmt.Errorf("Cannot parse duration field, err: %s", err.Error())
 			}
 		default: // Extra fields will not match predefined so they all show up here

cdrc/cdrc_test.go

@@ -55,7 +55,7 @@ func TestRecordForkCdr(t *testing.T) {
 		Destination: cdrRow[7],
 		SetupTime:   time.Date(2013, 2, 3, 19, 50, 0, 0, time.UTC),
 		AnswerTime:  time.Date(2013, 2, 3, 19, 54, 0, 0, time.UTC),
-		Duration:    time.Duration(62) * time.Second,
+		Usage:       time.Duration(62) * time.Second,
 		ExtraFields: map[string]string{"supplier": "supplier1"},
 		Cost:        -1,
 	}

cdre/csv_test.go

@@ -35,7 +35,7 @@ func TestCsvCdrWriter(t *testing.T) {
 	ratedCdr := &utils.StoredCdr{CgrId: utils.Sha1("dsafdsaf", time.Unix(1383813745, 0).UTC().String()), TOR: utils.VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1",
 		ReqType: "rated", Direction: "*out", Tenant: "cgrates.org",
 		Category: "call", Account: "1001", Subject: "1001", Destination: "1002", SetupTime: time.Unix(1383813745, 0).UTC(), AnswerTime: time.Unix(1383813746, 0).UTC(),
-		Duration: time.Duration(10) * time.Second, MediationRunId: utils.DEFAULT_RUNID,
+		Usage: time.Duration(10) * time.Second, MediationRunId: utils.DEFAULT_RUNID,
 		ExtraFields: map[string]string{"extra1": "val_extra1", "extra2": "val_extra2", "extra3": "val_extra3"}, Cost: 1.01,
 	}
 	csvCdrWriter.WriteCdr(ratedCdr)

cdre/fixedwidth.go

@@ -120,7 +120,7 @@ func (fwv *FixedWidthCdrWriter) cdrFieldValue(cdr *utils.StoredCdr, cfgHdr, layo
 		}
 	case utils.COST:
 		cdrVal = cdr.FormatCost(fwv.costShiftDigits, fwv.roundDecimals)
-	case utils.DURATION:
+	case utils.USAGE:
 		cdrVal = cdr.FormatDuration(layout)
 	case utils.SETUP_TIME:
 		cdrVal = cdr.SetupTime.Format(layout)
@@ -304,7 +304,7 @@ func (fwv *FixedWidthCdrWriter) WriteCdr(cdr *utils.StoredCdr) error {
 		fwv.lastCdrATime = cdr.AnswerTime
 	}
 	fwv.numberOfRecords += 1
-	fwv.totalDuration += cdr.Duration
+	fwv.totalDuration += cdr.Usage
 	fwv.totalCost += cdr.Cost
 	fwv.totalCost = utils.Round(fwv.totalCost, fwv.roundDecimals, utils.ROUNDING_MIDDLE)
 	if fwv.firstExpOrderId > cdr.OrderId || fwv.firstExpOrderId == 0 {

cdre/fixedwidth_test.go

@@ -47,7 +47,7 @@ var contentCfgFlds = []*config.CgrXmlCfgCdrField{
 	&config.CgrXmlCfgCdrField{Name: "TOR", Type: CONSTANT, Value: "02", Width: 2},
 	&config.CgrXmlCfgCdrField{Name: "SubtypeTOR", Type: CONSTANT, Value: "11", Width: 4, Padding: "right"},
 	&config.CgrXmlCfgCdrField{Name: "SetupTime", Type: CDRFIELD, Value: utils.SETUP_TIME, Width: 12, Strip: "right", Padding: "right", Layout: "020106150400"},
-	&config.CgrXmlCfgCdrField{Name: "Duration", Type: CDRFIELD, Value: utils.DURATION, Width: 6, Strip: "right", Padding: "right", Layout: utils.SECONDS},
+	&config.CgrXmlCfgCdrField{Name: "Duration", Type: CDRFIELD, Value: utils.USAGE, Width: 6, Strip: "right", Padding: "right", Layout: utils.SECONDS},
 	&config.CgrXmlCfgCdrField{Name: "DataVolume", Type: FILLER, Width: 6},
 	&config.CgrXmlCfgCdrField{Name: "TaxCode", Type: CONSTANT, Value: "1", Width: 1},
 	&config.CgrXmlCfgCdrField{Name: "OperatorCode", Type: CDRFIELD, Value: "opercode", Width: 2, Strip: "right", Padding: "right"},
@@ -85,7 +85,7 @@ func TestWriteCdr(t *testing.T) {
 		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),
-		Duration:   time.Duration(10) * time.Second, MediationRunId: utils.DEFAULT_RUNID, Cost: 2.34567,
+		Usage:      time.Duration(10) * time.Second, MediationRunId: utils.DEFAULT_RUNID, Cost: 2.34567,
 		ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
 	}
 	if err := fwWriter.WriteCdr(cdr); err != nil {
@@ -119,7 +119,7 @@ func TestWriteCdr(t *testing.T) {
 		t.Error("Unexpected lastCdrATime in stats: ", fwWriter.lastCdrATime)
 	} else if fwWriter.numberOfRecords != 1 {
 		t.Error("Unexpected number of records in the stats: ", fwWriter.numberOfRecords)
-	} else if fwWriter.totalDuration != cdr.Duration {
+	} else if fwWriter.totalDuration != cdr.Usage {
 		t.Error("Unexpected total duration in the stats: ", fwWriter.totalDuration)
 	} else if fwWriter.totalCost != utils.Round(cdr.Cost, fwWriter.roundDecimals, utils.ROUNDING_MIDDLE) {
 		t.Error("Unexpected total cost in the stats: ", fwWriter.totalCost)
@@ -146,14 +146,14 @@ func TestWriteCdrs(t *testing.T) {
 		Category: "call", Account: "1001", Subject: "1001", Destination: "1010",
 		SetupTime:  time.Date(2013, 11, 7, 8, 42, 20, 0, time.UTC),
 		AnswerTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC),
-		Duration:   time.Duration(10) * time.Second, MediationRunId: utils.DEFAULT_RUNID, Cost: 2.25,
+		Usage:      time.Duration(10) * time.Second, MediationRunId: utils.DEFAULT_RUNID, Cost: 2.25,
 		ExtraFields: map[string]string{"productnumber": "12341", "fieldextr2": "valextr2"},
 	}
 	cdr2 := &utils.StoredCdr{CgrId: utils.Sha1("aaa2", time.Date(2013, 11, 7, 7, 42, 20, 0, time.UTC).String()), OrderId: 4, AccId: "aaa2", CdrHost: "192.168.1.2", ReqType: "prepaid", Direction: "*out", Tenant: "cgrates.org",
 		Category: "call", Account: "1002", Subject: "1002", Destination: "1011",
 		SetupTime:  time.Date(2013, 11, 7, 7, 42, 20, 0, time.UTC),
 		AnswerTime: time.Date(2013, 11, 7, 7, 42, 26, 0, time.UTC),
-		Duration:   time.Duration(5) * time.Minute, MediationRunId: utils.DEFAULT_RUNID, Cost: 1.40001,
+		Usage:      time.Duration(5) * time.Minute, MediationRunId: utils.DEFAULT_RUNID, Cost: 1.40001,
 		ExtraFields: map[string]string{"productnumber": "12342", "fieldextr2": "valextr2"},
 	}
 	cdr3 := &utils.StoredCdr{}
@@ -161,7 +161,7 @@ func TestWriteCdrs(t *testing.T) {
 		Category: "call", Account: "1004", Subject: "1004", Destination: "1013",
 		SetupTime:  time.Date(2013, 11, 7, 9, 42, 18, 0, time.UTC),
 		AnswerTime: time.Date(2013, 11, 7, 9, 42, 26, 0, time.UTC),
-		Duration:   time.Duration(20) * time.Second, MediationRunId: utils.DEFAULT_RUNID, Cost: 2.34567,
+		Usage:      time.Duration(20) * time.Second, MediationRunId: utils.DEFAULT_RUNID, Cost: 2.34567,
 		ExtraFields: map[string]string{"productnumber": "12344", "fieldextr2": "valextr2"},
 	}
 	for _, cdr := range []*utils.StoredCdr{cdr1, cdr2, cdr3, cdr4} {

cdrs/fscdr.go

@@ -1,6 +1,6 @@
 /*
-Rating system designed to be used in VoIP Carriers World
-Copyright (C) 2013 ITsysCOM
+Real-time Charging System for Telecom & ISP environments
+Copyright (C) 2012-2014 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
@@ -137,7 +137,7 @@ func (fsCdr FSCdr) AsStoredCdr() *utils.StoredCdr {
 	storCdr.Destination = utils.FirstNonEmpty(fsCdr.vars[FS_DESTINATION], fsCdr.vars[FS_CALL_DEST_NR], fsCdr.vars[FS_SIP_REQUSER])
 	storCdr.SetupTime, _ = utils.ParseTimeDetectLayout(fsCdr.vars[FS_SETUP_TIME]) // Not interested to process errors, should do them if necessary in a previous step
 	storCdr.AnswerTime, _ = utils.ParseTimeDetectLayout(fsCdr.vars[FS_ANSWER_TIME])
-	storCdr.Duration, _ = utils.ParseDurationWithSecs(fsCdr.vars[FS_DURATION])
+	storCdr.Usage, _ = utils.ParseDurationWithSecs(fsCdr.vars[FS_DURATION])
 	storCdr.ExtraFields = fsCdr.getExtraFields()
 	storCdr.Cost = -1
 	return storCdr

cdrs/fscdr_test.go

@@ -56,7 +56,7 @@ func TestCDRFields(t *testing.T) {
 	answerTime, _ := utils.ParseTimeDetectLayout(fsCdr.vars[FS_ANSWER_TIME])
 	expctStoredCdr := &utils.StoredCdr{CgrId: utils.Sha1("01df56f4-d99a-4ef6-b7fe-b924b2415b7f", setupTime.String()), TOR: utils.VOICE, AccId: "01df56f4-d99a-4ef6-b7fe-b924b2415b7f",
 		CdrHost: "127.0.0.1", CdrSource: "freeswitch_json", Direction: "*out", Category: "call", ReqType: utils.RATED, Tenant: "ipbx.itsyscom.com", Account: "dan", Subject: "dan",
-		Destination: "+4986517174963", SetupTime: setupTime, AnswerTime: answerTime, Duration: time.Duration(4) * time.Second,
+		Destination: "+4986517174963", SetupTime: setupTime, AnswerTime: answerTime, Usage: time.Duration(4) * time.Second,
 		ExtraFields: map[string]string{"sip_user_agent": "Jitsi2.2.4603.9615Linux"}, Cost: -1}
 	if storedCdr := fsCdr.AsStoredCdr(); !reflect.DeepEqual(expctStoredCdr, storedCdr) {
 		t.Errorf("Expecting: %v, received: %v", expctStoredCdr, storedCdr)

config/config.go

@@ -191,7 +191,7 @@ func (self *CGRConfig) setDefaults() error {
 		utils.DESTINATION: &utils.RSRField{Id: "7"},
 		utils.SETUP_TIME:  &utils.RSRField{Id: "8"},
 		utils.ANSWER_TIME: &utils.RSRField{Id: "9"},
-		utils.DURATION:    &utils.RSRField{Id: "10"},
+		utils.USAGE:       &utils.RSRField{Id: "10"},
 	}
 	self.MediatorEnabled = false
 	self.MediatorRater = "internal"
@@ -231,7 +231,7 @@ func (self *CGRConfig) setDefaults() error {
 		&utils.RSRField{Id: utils.DESTINATION},
 		&utils.RSRField{Id: utils.SETUP_TIME},
 		&utils.RSRField{Id: utils.ANSWER_TIME},
-		&utils.RSRField{Id: utils.DURATION},
+		&utils.RSRField{Id: utils.USAGE},
 		&utils.RSRField{Id: utils.COST},
 	}
 	return nil

config/config_test.go

@@ -105,7 +105,7 @@ func TestDefaults(t *testing.T) {
 		utils.DESTINATION: &utils.RSRField{Id: "7"},
 		utils.SETUP_TIME:  &utils.RSRField{Id: "8"},
 		utils.ANSWER_TIME: &utils.RSRField{Id: "9"},
-		utils.DURATION:    &utils.RSRField{Id: "10"},
+		utils.USAGE:       &utils.RSRField{Id: "10"},
 	}
 	eCfg.MediatorEnabled = false
 	eCfg.MediatorRater = "internal"
@@ -145,7 +145,7 @@ func TestDefaults(t *testing.T) {
 		&utils.RSRField{Id: utils.DESTINATION},
 		&utils.RSRField{Id: utils.SETUP_TIME},
 		&utils.RSRField{Id: utils.ANSWER_TIME},
-		&utils.RSRField{Id: utils.DURATION},
+		&utils.RSRField{Id: utils.USAGE},
 		&utils.RSRField{Id: utils.COST},
 	}
 	if !reflect.DeepEqual(cfg, eCfg) {
@@ -250,7 +250,7 @@ func TestConfigFromFile(t *testing.T) {
 		utils.DESTINATION: &utils.RSRField{Id: "test"},
 		utils.SETUP_TIME:  &utils.RSRField{Id: "test"},
 		utils.ANSWER_TIME: &utils.RSRField{Id: "test"},
-		utils.DURATION:    &utils.RSRField{Id: "test"},
+		utils.USAGE:       &utils.RSRField{Id: "test"},
 		"test":            &utils.RSRField{Id: "test"},
 	}
 	eCfg.MediatorEnabled = true

config/helpers.go

@@ -161,7 +161,7 @@ func ParseCdrcCdrFields(accIdFld, reqtypeFld, directionFld, tenantFld, categoryF
 	}
 	for fldTag, fldVal := range map[string]string{utils.ACCID: accIdFld, utils.REQTYPE: reqtypeFld, utils.DIRECTION: directionFld, utils.TENANT: tenantFld,
 		utils.CATEGORY: categoryFld, utils.ACCOUNT: acntFld, utils.SUBJECT: subjectFld, utils.DESTINATION: destFld, utils.SETUP_TIME: setupTimeFld,
-		utils.ANSWER_TIME: answerTimeFld, utils.DURATION: durFld} {
+		utils.ANSWER_TIME: answerTimeFld, utils.USAGE: durFld} {
 		if len(fldVal) != 0 {
 			if rsrFld, err := utils.NewRSRField(fldVal); err != nil {
 				return nil, err

config/helpers_test.go

@@ -91,7 +91,7 @@ extra_fields = extra1:extraval1,extra2:extraval1
 		utils.DESTINATION: &utils.RSRField{Id: "destination1"},
 		utils.SETUP_TIME:  &utils.RSRField{Id: "setuptime1"},
 		utils.ANSWER_TIME: &utils.RSRField{Id: "answertime1"},
-		utils.DURATION:    &utils.RSRField{Id: "duration1"},
+		utils.USAGE:       &utils.RSRField{Id: "duration1"},
 		"extra1":          &utils.RSRField{Id: "extraval1"},
 		"extra2":          &utils.RSRField{Id: "extraval1"},
 	}

data/tariffplans/prepaid1centpsec/DestinationRates.csv

@@ -1,4 +1,4 @@
 #Tag,DestinationsTag,RatesTag,RoundingMethod,RoundingDecimals
-DR_RETAIL,GERMANY,RT_1CENT,*up,2
-DR_RETAIL,GERMANY_MOBILE,RT_1CENT,*up,2
-DR_DATA_1,*any,RT_DATA_2c,*up,2
+DR_RETAIL,GERMANY,RT_1CENT,*up,4
+DR_RETAIL,GERMANY_MOBILE,RT_1CENT,*up,4
+DR_DATA_1,*any,RT_DATA_2c,*up,4

engine/storage_sql.go

@@ -1,6 +1,6 @@
 /*
-Rating system designed to be used in VoIP Carriers World
-Copyright (C) 2013 ITsysCOM
+Real-time Charging System for Telecom & ISP environments
+Copyright (C) 2012-2014 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
@@ -560,7 +560,7 @@ func (self *SQLStorage) SetCdr(cdr *utils.StoredCdr) (err error) {
 		cdr.Destination,
 		cdr.SetupTime,
 		cdr.AnswerTime,
-		cdr.Duration,
+		cdr.Usage,
 	))
 	if err != nil {
 		Logger.Err(fmt.Sprintf("failed to execute cdr insert statement: %v", err))
@@ -595,7 +595,7 @@ func (self *SQLStorage) SetRatedCdr(storedCdr *utils.StoredCdr, extraInfo string
 		storedCdr.Destination,
 		storedCdr.SetupTime,
 		storedCdr.AnswerTime,
-		storedCdr.Duration,
+		storedCdr.Usage,
 		storedCdr.Cost,
 		extraInfo))
 	if err != nil {
@@ -909,7 +909,7 @@ func (self *SQLStorage) GetStoredCdrs(cgrIds, runIds, tors, cdrHosts, cdrSources
 			CgrId: cgrid.String, OrderId: orderid, TOR: tor.String, AccId: accid.String, CdrHost: cdrhost.String, CdrSource: cdrsrc.String, ReqType: reqtype.String,
 			Direction: direction.String, Tenant: tenant.String,
 			Category: category.String, Account: account.String, Subject: subject.String, Destination: destination.String,
-			SetupTime: setupTime.Time, AnswerTime: answerTime.Time, Duration: time.Duration(usage.Int64),
+			SetupTime: setupTime.Time, AnswerTime: answerTime.Time, Usage: time.Duration(usage.Int64),
 			ExtraFields: extraFieldsMp, MediationRunId: runid.String, Cost: cost.Float64,
 		}
 		if !cost.Valid { //There was no cost provided, will fakely insert 0 if we do not handle it and reflect on re-rating

engine/storage_sql_local_test.go

@@ -139,22 +139,22 @@ func TestSetCdr(t *testing.T) {
 	}
 	cgrCdr1 := &utils.CgrCdr{utils.TOR: utils.VOICE, utils.ACCID: "aaa1", utils.CDRHOST: "192.168.1.1", utils.REQTYPE: "rated", utils.DIRECTION: "*out", utils.TENANT: "cgrates.org",
 		utils.CATEGORY: "call", utils.ACCOUNT: "1001", utils.SUBJECT: "1001", utils.DESTINATION: "1002", utils.SETUP_TIME: "2013-11-08T08:42:20Z",
-		utils.ANSWER_TIME: "2013-11-08T08:42:26Z", utils.DURATION: "10s", "field_extr1": "val_extr1", "fieldextr2": "valextr2", utils.CDRSOURCE: TEST_SQL}
+		utils.ANSWER_TIME: "2013-11-08T08:42:26Z", utils.USAGE: "10s", "field_extr1": "val_extr1", "fieldextr2": "valextr2", utils.CDRSOURCE: TEST_SQL}
 	cgrCdr2 := &utils.CgrCdr{utils.TOR: utils.VOICE, utils.ACCID: "aaa2", utils.CDRHOST: "192.168.1.1", utils.REQTYPE: "prepaid", utils.DIRECTION: "*out", utils.TENANT: "cgrates.org",
 		utils.CATEGORY: "call", utils.ACCOUNT: "1001", utils.SUBJECT: "1001", utils.DESTINATION: "1002", utils.SETUP_TIME: "2013-11-08T08:42:22Z",
-		utils.ANSWER_TIME: "2013-11-08T08:42:26Z", utils.DURATION: "20", "field_extr1": "val_extr1", "fieldextr2": "valextr2", "cdrsource": TEST_SQL}
+		utils.ANSWER_TIME: "2013-11-08T08:42:26Z", utils.USAGE: "20", "field_extr1": "val_extr1", "fieldextr2": "valextr2", "cdrsource": TEST_SQL}
 
 	cgrCdr3 := &utils.CgrCdr{utils.TOR: utils.VOICE, utils.ACCID: "aaa3", utils.CDRHOST: "192.168.1.1", utils.REQTYPE: "rated", utils.DIRECTION: "*out", utils.TENANT: "cgrates.org",
 		utils.CATEGORY: "premium_call", utils.ACCOUNT: "1002", utils.SUBJECT: "1002", utils.DESTINATION: "1001", utils.SETUP_TIME: "2013-11-07T08:42:24Z",
-		utils.ANSWER_TIME: "2013-11-07T08:42:26Z", utils.DURATION: "60s", "field_extr1": "val_extr1", "fieldextr2": "valextr2", "cdrsource": TEST_SQL}
+		utils.ANSWER_TIME: "2013-11-07T08:42:26Z", utils.USAGE: "60s", "field_extr1": "val_extr1", "fieldextr2": "valextr2", "cdrsource": TEST_SQL}
 
 	cgrCdr4 := &utils.CgrCdr{utils.TOR: utils.VOICE, utils.ACCID: "aaa4", utils.CDRHOST: "192.168.1.2", utils.REQTYPE: "pseudoprepaid", utils.DIRECTION: "*out", utils.TENANT: "itsyscom.com",
 		utils.CATEGORY: "call", utils.ACCOUNT: "1001", utils.SUBJECT: "1001", utils.DESTINATION: "+4986517174964", utils.SETUP_TIME: "2013-11-07T08:42:21Z",
-		utils.ANSWER_TIME: "2013-11-07T08:42:26Z", utils.DURATION: "1m2s", "field_extr1": "val_extr1", "fieldextr2": "valextr2", "cdrsource": TEST_SQL}
+		utils.ANSWER_TIME: "2013-11-07T08:42:26Z", utils.USAGE: "1m2s", "field_extr1": "val_extr1", "fieldextr2": "valextr2", "cdrsource": TEST_SQL}
 
 	cgrCdr5 := &utils.CgrCdr{utils.TOR: utils.VOICE, utils.ACCID: "aaa5", utils.CDRHOST: "192.168.1.2", utils.REQTYPE: "postpaid", utils.DIRECTION: "*out", utils.TENANT: "itsyscom.com",
 		utils.CATEGORY: "call", utils.ACCOUNT: "1002", utils.SUBJECT: "1002", utils.DESTINATION: "+4986517174963", utils.SETUP_TIME: "2013-11-07T08:42:25Z",
-		utils.ANSWER_TIME: "2013-11-07T08:42:26Z", utils.DURATION: "15s", "field_extr1": "val_extr1", "fieldextr2": "valextr2", "cdrsource": TEST_SQL}
+		utils.ANSWER_TIME: "2013-11-07T08:42:26Z", utils.USAGE: "15s", "field_extr1": "val_extr1", "fieldextr2": "valextr2", "cdrsource": TEST_SQL}
 
 	for _, cdr := range []*utils.CgrCdr{cgrCdr1, cgrCdr2, cgrCdr3, cgrCdr4, cgrCdr5} {
 		if err := mysqlDb.SetCdr(cdr.AsStoredCdr()); err != nil {
@@ -164,19 +164,19 @@ func TestSetCdr(t *testing.T) {
 	strCdr1 := &utils.StoredCdr{TOR: utils.VOICE, AccId: "bbb1", CdrHost: "192.168.1.1", CdrSource: "UNKNOWN", ReqType: "rated",
 		Direction: "*out", Tenant: "cgrates.org", Category: "call", Account: "1001", Subject: "1001", Destination: "1002",
 		SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC), AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
 		MediationRunId: utils.DEFAULT_RUNID, Cost: 1.201}
 	strCdr1.CgrId = utils.Sha1(strCdr1.AccId, strCdr1.SetupTime.String())
 	strCdr2 := &utils.StoredCdr{TOR: utils.VOICE, AccId: "bbb2", CdrHost: "192.168.1.2", CdrSource: "UNKNOWN2", ReqType: "prepaid",
 		Direction: "*out", Tenant: "cgrates.org", Category: "call", Account: "1001", Subject: "1001", Destination: "1002",
 		SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC), AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
-		Duration: time.Duration(12) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
+		Usage: time.Duration(12) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
 		MediationRunId: utils.DEFAULT_RUNID, Cost: 0.201}
 	strCdr2.CgrId = utils.Sha1(strCdr2.AccId, strCdr2.SetupTime.String())
 	strCdr3 := &utils.StoredCdr{TOR: utils.VOICE, AccId: "bbb3", CdrHost: "192.168.1.1", CdrSource: TEST_SQL, ReqType: "rated",
 		Direction: "*out", Tenant: "itsyscom.com", Category: "call", Account: "1002", Subject: "1000", Destination: "+4986517174963",
 		SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC), AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
 		MediationRunId: utils.DEFAULT_RUNID, Cost: 1.201}
 	strCdr3.CgrId = utils.Sha1(strCdr3.AccId, strCdr3.SetupTime.String())
 
@@ -194,19 +194,19 @@ func TestSetRatedCdr(t *testing.T) {
 	strCdr1 := &utils.StoredCdr{TOR: utils.VOICE, AccId: "bbb1", CdrHost: "192.168.1.1", CdrSource: "UNKNOWN", ReqType: "rated",
 		Direction: "*out", Tenant: "cgrates.org", Category: "call", Account: "1001", Subject: "1001", Destination: "1002",
 		SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC), AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
 		MediationRunId: utils.DEFAULT_RUNID, Cost: 1.201}
 	strCdr1.CgrId = utils.Sha1(strCdr1.AccId, strCdr1.SetupTime.String())
 	strCdr2 := &utils.StoredCdr{TOR: utils.VOICE, AccId: "bbb2", CdrHost: "192.168.1.2", CdrSource: "UNKNOWN", ReqType: "prepaid",
 		Direction: "*out", Tenant: "cgrates.org", Category: "call", Account: "1001", Subject: "1001", Destination: "1002",
 		SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC), AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
-		Duration: time.Duration(12) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
+		Usage: time.Duration(12) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
 		MediationRunId: utils.DEFAULT_RUNID, Cost: 0.201}
 	strCdr2.CgrId = utils.Sha1(strCdr2.AccId, strCdr2.SetupTime.String())
 	strCdr3 := &utils.StoredCdr{TOR: utils.VOICE, AccId: "bbb3", CdrHost: "192.168.1.1", CdrSource: TEST_SQL, ReqType: "rated",
 		Direction: "*out", Tenant: "itsyscom.com", Category: "call", Account: "1002", Subject: "1002", Destination: "+4986517174964",
 		SetupTime: time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC), AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC),
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"},
 		MediationRunId: "wholesale_run", Cost: 1.201}
 	strCdr3.CgrId = utils.Sha1(strCdr3.AccId, strCdr3.SetupTime.String())
 

general_tests/datachrg1_test.go

@@ -27,14 +27,14 @@ import (
 	"github.com/cgrates/cgrates/utils"
 )
 
-func TestDataSetStorageDtChrg1(t *testing.T) {
+func TestSetStorageDtChrg1(t *testing.T) {
 	ratingDb, _ = engine.NewMapStorageJson()
 	engine.SetRatingStorage(ratingDb)
 	acntDb, _ = engine.NewMapStorageJson()
 	engine.SetAccountingStorage(acntDb)
 }
 
-func TestDataLoadCsvTpDtChrg1(t *testing.T) {
+func TestLoadCsvTpDtChrg1(t *testing.T) {
 	timings := `ALWAYS,*any,*any,*any,*any,00:00:00`
 	rates := `RT_DATA_2c,0,0.002,10,10,0`
 	destinationRates := `DR_DATA_1,*any,RT_DATA_2c,*up,4`
@@ -68,7 +68,7 @@ func TestDataLoadCsvTpDtChrg1(t *testing.T) {
 	}
 }
 
-func TestDataGetCostDtChrg1(t *testing.T) {
+func TestGetDataCostDtChrg1(t *testing.T) {
 	usedData := 20
 	usageDur := time.Duration(usedData) * time.Second
 	timeStart := time.Date(2014, 3, 4, 6, 0, 0, 0, time.UTC)
@@ -83,11 +83,9 @@ func TestDataGetCostDtChrg1(t *testing.T) {
 		DurationIndex: usageDur,
 		TOR:           utils.DATA,
 	}
-	expected := 0.004
 	if cc, err := cd.GetCost(); err != nil {
 		t.Error(err)
-	} else if cc.Cost != expected {
-		t.Logf("CC: %+v", cc.Timespans[0].RateInterval.Rating)
-		t.Errorf("expected: %v was: %v", expected, cc.Cost)
+	} else if cc.Cost != 0.004 {
+		t.Error("Wrong cost returned: ", cc.Cost)
 	}
 }

mediator/mediator.go

@@ -61,7 +61,7 @@ func (self *Mediator) getCostsFromDB(cgrid, runId string) (cc *engine.CallCost,
 func (self *Mediator) getCostFromRater(storedCdr *utils.StoredCdr) (*engine.CallCost, error) {
 	cc := &engine.CallCost{}
 	var err error
-	if storedCdr.Duration == time.Duration(0) { // failed call,  returning empty callcost, no error
+	if storedCdr.Usage == time.Duration(0) { // failed call,  returning empty callcost, no error
 		return cc, nil
 	}
 	cd := engine.CallDescriptor{
@@ -73,8 +73,8 @@ func (self *Mediator) getCostFromRater(storedCdr *utils.StoredCdr) (*engine.Call
 		Account:       storedCdr.Account,
 		Destination:   storedCdr.Destination,
 		TimeStart:     storedCdr.AnswerTime,
-		TimeEnd:       storedCdr.AnswerTime.Add(storedCdr.Duration),
-		DurationIndex: storedCdr.Duration,
+		TimeEnd:       storedCdr.AnswerTime.Add(storedCdr.Usage),
+		DurationIndex: storedCdr.Usage,
 	}
 	if storedCdr.ReqType == utils.PSEUDOPREPAID {
 		err = self.connector.Debit(cd, cc)

utils/cgrcdr.go

@@ -69,7 +69,7 @@ func (cgrCdr CgrCdr) AsStoredCdr() *StoredCdr {
 	storCdr.Destination = cgrCdr[DESTINATION]
 	storCdr.SetupTime, _ = ParseTimeDetectLayout(cgrCdr[SETUP_TIME]) // Not interested to process errors, should do them if necessary in a previous step
 	storCdr.AnswerTime, _ = ParseTimeDetectLayout(cgrCdr[ANSWER_TIME])
-	storCdr.Duration, _ = ParseDurationWithSecs(cgrCdr[USAGE])
+	storCdr.Usage, _ = ParseDurationWithSecs(cgrCdr[USAGE])
 	storCdr.ExtraFields = cgrCdr.getExtraFields()
 	storCdr.Cost = -1
 	return storCdr

utils/cgrcdr_test.go

@@ -39,7 +39,7 @@ func TestCgrCdrAsStoredCdr(t *testing.T) {
 	setupTime, _ := ParseTimeDetectLayout(cgrCdr["setup_time"])
 	expctRtCdr := &StoredCdr{CgrId: Sha1(cgrCdr["accid"], setupTime.String()), TOR: VOICE, AccId: cgrCdr["accid"], CdrHost: cgrCdr["cdrhost"], CdrSource: cgrCdr["cdrsource"], ReqType: cgrCdr["reqtype"],
 		Direction: cgrCdr[DIRECTION], Tenant: cgrCdr["tenant"], Category: cgrCdr[CATEGORY], Account: cgrCdr["account"], Subject: cgrCdr["subject"],
-		Destination: cgrCdr["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), Duration: time.Duration(10) * time.Second,
+		Destination: cgrCdr["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,
 		ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: -1}
 	if storedCdr := cgrCdr.AsStoredCdr(); !reflect.DeepEqual(expctRtCdr, storedCdr) {
 		t.Errorf("Expecting %v, received: %v", expctRtCdr, storedCdr)

utils/consts.go

@@ -87,7 +87,6 @@ const (
 	DESTINATION                = "destination"
 	SETUP_TIME                 = "setup_time"
 	ANSWER_TIME                = "answer_time"
-	DURATION                   = "duration"
 	USAGE                      = "usage"
 	MEDI_RUNID                 = "mediation_runid"
 	COST                       = "cost"

utils/storedcdr.go

@@ -44,7 +44,7 @@ type StoredCdr struct {
 	Destination    string
 	SetupTime      time.Time
 	AnswerTime     time.Time
-	Duration       time.Duration
+	Usage          time.Duration
 	ExtraFields    map[string]string
 	MediationRunId string
 	Cost           float64
@@ -59,16 +59,17 @@ func (storedCdr *StoredCdr) FormatCost(shiftDecimals, roundDecimals int) string
 	return strconv.FormatFloat(cost, 'f', roundDecimals, 64)
 }
 
+// Rounds up so 0.8 seconds will become 1
 func (storedCdr *StoredCdr) FormatDuration(layout string) string {
 	switch layout {
 	case HOURS:
-		return strconv.FormatFloat(storedCdr.Duration.Hours(), 'f', -1, 64)
+		return strconv.FormatFloat(math.Ceil(storedCdr.Usage.Hours()), 'f', -1, 64)
 	case MINUTES:
-		return strconv.FormatFloat(storedCdr.Duration.Minutes(), 'f', -1, 64)
+		return strconv.FormatFloat(math.Ceil(storedCdr.Usage.Minutes()), 'f', -1, 64)
 	case SECONDS:
-		return strconv.FormatFloat(storedCdr.Duration.Seconds(), 'f', -1, 64)
+		return strconv.FormatFloat(math.Ceil(storedCdr.Usage.Seconds()), 'f', -1, 64)
 	default:
-		return strconv.FormatInt(storedCdr.Duration.Nanoseconds(), 10)
+		return strconv.FormatInt(storedCdr.Usage.Nanoseconds(), 10)
 	}
 }
 
@@ -105,8 +106,8 @@ func (storedCdr *StoredCdr) FieldAsString(rsrFld *RSRField) string {
 		return rsrFld.ParseValue(storedCdr.SetupTime.String())
 	case ANSWER_TIME:
 		return rsrFld.ParseValue(storedCdr.AnswerTime.String())
-	case DURATION:
-		return rsrFld.ParseValue(strconv.FormatInt(storedCdr.Duration.Nanoseconds(), 10))
+	case USAGE:
+		return rsrFld.ParseValue(strconv.FormatInt(storedCdr.Usage.Nanoseconds(), 10))
 	case MEDI_RUNID:
 		return rsrFld.ParseValue(storedCdr.MediationRunId)
 	case COST:
@@ -139,7 +140,7 @@ func (storedCdr *StoredCdr) AsHttpForm() url.Values {
 	v.Set(DESTINATION, storedCdr.Destination)
 	v.Set(SETUP_TIME, storedCdr.SetupTime.String())
 	v.Set(ANSWER_TIME, storedCdr.AnswerTime.String())
-	v.Set(DURATION, strconv.FormatInt(storedCdr.Duration.Nanoseconds(), 10))
+	v.Set(USAGE, strconv.FormatInt(storedCdr.Usage.Nanoseconds(), 10))
 	return v
 }
 
@@ -175,7 +176,7 @@ func (storedCdr *StoredCdr) ForkCdr(runId string, reqTypeFld, directionFld, tena
 		answerTimeFld.Id = ANSWER_TIME
 	}
 	if durationFld.Id == META_DEFAULT {
-		durationFld.Id = DURATION
+		durationFld.Id = USAGE
 	}
 	var err error
 	frkStorCdr := new(StoredCdr)
@@ -228,8 +229,8 @@ func (storedCdr *StoredCdr) ForkCdr(runId string, reqTypeFld, directionFld, tena
 	}
 	durStr := storedCdr.FieldAsString(durationFld)
 	if primaryMandatory && len(durStr) == 0 {
-		return nil, errors.New(fmt.Sprintf("%s:%s:%s", ERR_MANDATORY_IE_MISSING, DURATION, durationFld.Id))
-	} else if frkStorCdr.Duration, err = ParseDurationWithNanosecs(durStr); err != nil {
+		return nil, errors.New(fmt.Sprintf("%s:%s:%s", ERR_MANDATORY_IE_MISSING, USAGE, durationFld.Id))
+	} else if frkStorCdr.Usage, err = ParseDurationWithNanosecs(durStr); err != nil {
 		return nil, err
 	}
 	frkStorCdr.ExtraFields = make(map[string]string, len(extraFlds))

utils/storedcdr_test.go

@@ -32,7 +32,7 @@ func TestStoredCdrInterfaces(t *testing.T) {
 func TestFieldAsString(t *testing.T) {
 	cdr := StoredCdr{CgrId: Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC).String()), OrderId: 123, TOR: VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1", CdrSource: "test", ReqType: "rated", Direction: "*out", Tenant: "cgrates.org",
 		Category: "call", Account: "1001", Subject: "1001", Destination: "1002", SetupTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), AnswerTime: time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC), MediationRunId: DEFAULT_RUNID,
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01,
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01,
 	}
 	if cdr.FieldAsString(&RSRField{Id: CGRID}) != cdr.CgrId ||
 		cdr.FieldAsString(&RSRField{Id: ORDERID}) != "123" ||
@@ -48,7 +48,7 @@ func TestFieldAsString(t *testing.T) {
 		cdr.FieldAsString(&RSRField{Id: DESTINATION}) != cdr.Destination ||
 		cdr.FieldAsString(&RSRField{Id: SETUP_TIME}) != cdr.SetupTime.String() ||
 		cdr.FieldAsString(&RSRField{Id: ANSWER_TIME}) != cdr.AnswerTime.String() ||
-		cdr.FieldAsString(&RSRField{Id: DURATION}) != "10000000000" ||
+		cdr.FieldAsString(&RSRField{Id: USAGE}) != "10000000000" ||
 		cdr.FieldAsString(&RSRField{Id: MEDI_RUNID}) != cdr.MediationRunId ||
 		cdr.FieldAsString(&RSRField{Id: COST}) != "1.01" ||
 		cdr.FieldAsString(&RSRField{Id: "field_extr1"}) != cdr.ExtraFields["field_extr1"] ||
@@ -69,7 +69,7 @@ func TestFieldAsString(t *testing.T) {
 			cdr.FieldAsString(&RSRField{Id: DESTINATION}) != cdr.Destination,
 			cdr.FieldAsString(&RSRField{Id: SETUP_TIME}) != cdr.SetupTime.String(),
 			cdr.FieldAsString(&RSRField{Id: ANSWER_TIME}) != cdr.AnswerTime.String(),
-			cdr.FieldAsString(&RSRField{Id: DURATION}) != "10000000000",
+			cdr.FieldAsString(&RSRField{Id: USAGE}) != "10000000000",
 			cdr.FieldAsString(&RSRField{Id: MEDI_RUNID}) != cdr.MediationRunId,
 			cdr.FieldAsString(&RSRField{Id: COST}) != "1.01",
 			cdr.FieldAsString(&RSRField{Id: "field_extr1"}) != cdr.ExtraFields["field_extr1"],
@@ -99,7 +99,7 @@ func TestFormatCost(t *testing.T) {
 }
 
 func TestFormatDuration(t *testing.T) {
-	cdr := StoredCdr{Duration: time.Duration(10) * time.Second}
+	cdr := StoredCdr{Usage: time.Duration(10) * time.Second}
 	if cdr.FormatDuration(SECONDS) != "10" {
 		t.Error("Wrong duration format: ", cdr.FormatDuration(SECONDS))
 	}
@@ -112,7 +112,7 @@ func TestStoredCdrAsHttpForm(t *testing.T) {
 	storCdr := StoredCdr{CgrId: Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC).String()), OrderId: 123, TOR: VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1",
 		CdrSource: UNIT_TEST, ReqType: "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), MediationRunId: DEFAULT_RUNID,
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01,
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01,
 	}
 	cdrForm := storCdr.AsHttpForm()
 	if cdrForm.Get(TOR) != VOICE {
@@ -154,8 +154,8 @@ func TestStoredCdrAsHttpForm(t *testing.T) {
 	if cdrForm.Get(ANSWER_TIME) != "2013-11-07 08:42:26 +0000 UTC" {
 		t.Errorf("Expected: %s, received: %s", "2013-11-07 08:42:26 +0000 UTC", cdrForm.Get(ANSWER_TIME))
 	}
-	if cdrForm.Get(DURATION) != "10000000000" {
-		t.Errorf("Expected: %s, received: %s", "10000000000", cdrForm.Get(DURATION))
+	if cdrForm.Get(USAGE) != "10000000000" {
+		t.Errorf("Expected: %s, received: %s", "10000000000", cdrForm.Get(USAGE))
 	}
 	if cdrForm.Get("field_extr1") != "val_extr1" {
 		t.Errorf("Expected: %s, received: %s", "val_extr1", cdrForm.Get("field_extr1"))
@@ -169,10 +169,10 @@ func TestStoredCdrForkCdr(t *testing.T) {
 	storCdr := StoredCdr{CgrId: Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 26, 0, time.UTC).String()), OrderId: 123, TOR: VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1",
 		CdrSource: UNIT_TEST, ReqType: "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), MediationRunId: DEFAULT_RUNID,
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "field_extr2": "valextr2"}, Cost: 1.01,
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "field_extr2": "valextr2"}, Cost: 1.01,
 	}
 	rtSampleCdrOut, err := storCdr.ForkCdr("sample_run1", &RSRField{Id: REQTYPE}, &RSRField{Id: DIRECTION}, &RSRField{Id: TENANT}, &RSRField{Id: CATEGORY},
-		&RSRField{Id: ACCOUNT}, &RSRField{Id: SUBJECT}, &RSRField{Id: DESTINATION}, &RSRField{Id: SETUP_TIME}, &RSRField{Id: ANSWER_TIME}, &RSRField{Id: DURATION},
+		&RSRField{Id: ACCOUNT}, &RSRField{Id: SUBJECT}, &RSRField{Id: DESTINATION}, &RSRField{Id: SETUP_TIME}, &RSRField{Id: ANSWER_TIME}, &RSRField{Id: USAGE},
 		[]*RSRField{&RSRField{Id: "field_extr1"}, &RSRField{Id: "field_extr2"}}, true)
 	if err != nil {
 		t.Error("Unexpected error received", err)
@@ -180,7 +180,7 @@ func TestStoredCdrForkCdr(t *testing.T) {
 	expctSplRatedCdr := &StoredCdr{CgrId: storCdr.CgrId, TOR: VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1", CdrSource: UNIT_TEST, ReqType: "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),
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "field_extr2": "valextr2"}, MediationRunId: "sample_run1", Cost: -1}
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "field_extr2": "valextr2"}, MediationRunId: "sample_run1", Cost: -1}
 	if !reflect.DeepEqual(expctSplRatedCdr, rtSampleCdrOut) {
 		t.Errorf("Expected: %v, received: %v", expctSplRatedCdr, rtSampleCdrOut)
 	}
@@ -190,7 +190,7 @@ func TestStoredCdrForkCdrStaticVals(t *testing.T) {
 	storCdr := StoredCdr{CgrId: Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 20, 0, time.UTC).String()), OrderId: 123, TOR: VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1",
 		CdrSource: UNIT_TEST, ReqType: "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), MediationRunId: DEFAULT_RUNID,
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01,
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01,
 	}
 	rsrStPostpaid, _ := NewRSRField("^postpaid")
 	rsrStIn, _ := NewRSRField("^*in")
@@ -210,7 +210,7 @@ func TestStoredCdrForkCdrStaticVals(t *testing.T) {
 	expctRatedCdr2 := &StoredCdr{CgrId: storCdr.CgrId, TOR: VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1", CdrSource: UNIT_TEST, ReqType: "postpaid",
 		Direction: "*in", Tenant: "cgrates.com", Category: "premium_call", Account: "first_account", Subject: "first_subject", Destination: "1002",
 		SetupTime:  time.Date(2013, 12, 7, 8, 42, 24, 0, time.UTC),
-		AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC), Duration: time.Duration(12) * time.Second,
+		AnswerTime: time.Date(2013, 12, 7, 8, 42, 26, 0, time.UTC), Usage: time.Duration(12) * time.Second,
 		ExtraFields: map[string]string{}, MediationRunId: "wholesale_run", Cost: -1}
 	if !reflect.DeepEqual(rtCdrOut2, expctRatedCdr2) {
 		t.Errorf("Received: %v, expected: %v", rtCdrOut2, expctRatedCdr2)
@@ -227,12 +227,12 @@ func TestStoredCdrForkCdrFromMetaDefaults(t *testing.T) {
 	storCdr := StoredCdr{CgrId: Sha1("dsafdsaf", time.Date(2013, 11, 7, 8, 42, 20, 0, time.UTC).String()), OrderId: 123, TOR: VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1",
 		CdrSource: UNIT_TEST, ReqType: "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), MediationRunId: DEFAULT_RUNID,
-		Duration: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01,
+		Usage: time.Duration(10) * time.Second, ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, Cost: 1.01,
 	}
 	expctCdr := &StoredCdr{CgrId: storCdr.CgrId, TOR: VOICE, AccId: "dsafdsaf", CdrHost: "192.168.1.1", CdrSource: UNIT_TEST, ReqType: "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),
-		Duration:    time.Duration(10) * time.Second,
+		Usage:       time.Duration(10) * time.Second,
 		ExtraFields: map[string]string{"field_extr1": "val_extr1", "fieldextr2": "valextr2"}, MediationRunId: "wholesale_run", Cost: -1}
 	cdrOut, err := storCdr.ForkCdr("wholesale_run", &RSRField{Id: META_DEFAULT}, &RSRField{Id: META_DEFAULT}, &RSRField{Id: META_DEFAULT}, &RSRField{Id: META_DEFAULT},
 		&RSRField{Id: META_DEFAULT}, &RSRField{Id: META_DEFAULT}, &RSRField{Id: META_DEFAULT},