// Deprecated in rc8, replaced by AddAccountActionTriggers
func (self *ApierV1) AddTriggeredAction(attr AttrAddActionTrigger, reply *string) error {
if missing := utils.MissingStructFields(&attr, []string{"Tenant", "Account"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
at := &engine.ActionTrigger{
ID: attr.ActionTriggersId,
ThresholdType: attr.ThresholdType,
ThresholdValue: attr.ThresholdValue,
Balance: new(engine.BalanceFilter),
Weight: attr.Weight,
ActionsID: attr.ActionsId,
}
if attr.BalanceId != "" {
at.Balance.ID = utils.StringPointer(attr.BalanceId)
}
if attr.BalanceType != "" {
at.Balance.Type = utils.StringPointer(attr.BalanceType)
}
if attr.BalanceDirection != "" {
at.Balance.Directions = &utils.StringMap{attr.BalanceDirection: true}
}
if attr.BalanceDestinationIds != "" {
dstIDsMp := utils.StringMapFromSlice(strings.Split(attr.BalanceDestinationIds, utils.INFIELD_SEP))
at.Balance.DestinationIDs = &dstIDsMp
}
if attr.BalanceRatingSubject != "" {
at.Balance.RatingSubject = utils.StringPointer(attr.BalanceRatingSubject)
}
if attr.BalanceWeight != 0.0 {
at.Balance.Weight = utils.Float64Pointer(attr.BalanceWeight)
}
if balExpiryTime, err := utils.ParseTimeDetectLayout(attr.BalanceExpiryTime, self.Config.DefaultTimezone); err != nil {
return utils.NewErrServerError(err)
} else {
at.Balance.ExpirationDate = &balExpiryTime
}
if attr.BalanceSharedGroup != "" {
at.Balance.SharedGroups = &utils.StringMap{attr.BalanceSharedGroup: true}
}
acntID := utils.AccountKey(attr.Tenant, attr.Account)
_, err := engine.Guardian.Guard(func() (interface{}, error) {
acnt, err := self.AccountDb.GetAccount(acntID)
if err != nil {
return 0, err
}
acnt.ActionTriggers = append(acnt.ActionTriggers, at)
if err = self.AccountDb.SetAccount(acnt); err != nil {
return 0, err
}
return 0, nil
}, 0, acntID)
if err != nil {
return err
}
*reply = OK
return nil
}
func (attr *AttrSetBalance) SetBalance(b *engine.Balance) {
if b == nil {
return
}
if attr.Directions != nil {
b.Directions = utils.StringMapFromSlice(*attr.Directions)
}
if attr.Value != nil {
b.Value = *attr.Value
}
if attr.ExpiryTime != nil {
b.ExpirationDate = attr.expTime
}
if attr.RatingSubject != nil {
b.RatingSubject = *attr.RatingSubject
}
if attr.Categories != nil {
b.Categories = utils.StringMapFromSlice(*attr.Categories)
}
if attr.DestinationIDs != nil {
b.DestinationIds = utils.StringMapFromSlice(*attr.DestinationIDs)
}
if attr.SharedGroups != nil {
b.SharedGroups = utils.StringMapFromSlice(*attr.SharedGroups)
}
if attr.TimingIDs != nil {
b.TimingIDs = utils.StringMapFromSlice(*attr.TimingIDs)
}
if attr.Weight != nil {
b.Weight = *attr.Weight
}
if attr.Blocker != nil {
b.Blocker = *attr.Blocker
}
if attr.Disabled != nil {
b.Disabled = *attr.Disabled
}
b.SetDirty() // Mark the balance as dirty since we have modified and it should be checked by action triggers
}
func (self *DARequestProcessor) loadFromJsonCfg(jsnCfg *DARequestProcessorJsnCfg) error {
if jsnCfg == nil {
return nil
}
if jsnCfg.Id != nil {
self.Id = *jsnCfg.Id
}
if jsnCfg.Dry_run != nil {
self.DryRun = *jsnCfg.Dry_run
}
if jsnCfg.Publish_event != nil {
self.PublishEvent = *jsnCfg.Publish_event
}
var err error
if jsnCfg.Request_filter != nil {
if self.RequestFilter, err = utils.ParseRSRFields(*jsnCfg.Request_filter, utils.INFIELD_SEP); err != nil {
return err
}
}
if jsnCfg.Flags != nil {
self.Flags = utils.StringMapFromSlice(*jsnCfg.Flags)
}
if jsnCfg.Continue_on_success != nil {
self.ContinueOnSuccess = *jsnCfg.Continue_on_success
}
if jsnCfg.Append_cca != nil {
self.AppendCCA = *jsnCfg.Append_cca
}
if jsnCfg.CCR_fields != nil {
if self.CCRFields, err = CfgCdrFieldsFromCdrFieldsJsonCfg(*jsnCfg.CCR_fields); err != nil {
return err
}
}
if jsnCfg.CCA_fields != nil {
if self.CCAFields, err = CfgCdrFieldsFromCdrFieldsJsonCfg(*jsnCfg.CCA_fields); err != nil {
return err
}
}
return nil
}
// Used by SM to get all the prepaid CallDescriptors attached to a session
func (rs *Responder) GetSessionRuns(ev *CDR, sRuns *[]*SessionRun) error {
if rs.Bal != nil {
return errors.New("Unsupported method on the balancer")
}
cacheKey := utils.GET_SESS_RUNS_CACHE_PREFIX + ev.CGRID
if item, err := rs.getCache().Get(cacheKey); err == nil && item != nil {
if item.Value != nil {
*sRuns = *(item.Value.(*[]*SessionRun))
}
return item.Err
}
if ev.Subject == "" {
ev.Subject = ev.Account
}
//utils.Logger.Info(fmt.Sprintf("DC before: %+v", ev))
// replace user profile fields
if err := LoadUserProfile(ev, utils.EXTRA_FIELDS); err != nil {
return err
}
// replace aliases
if err := LoadAlias(
&AttrMatchingAlias{
Destination: ev.Destination,
Direction: ev.Direction,
Tenant: ev.Tenant,
Category: ev.Category,
Account: ev.Account,
Subject: ev.Subject,
Context: utils.ALIAS_CONTEXT_RATING,
}, ev, utils.EXTRA_FIELDS); err != nil && err != utils.ErrNotFound {
return err
}
//utils.Logger.Info(fmt.Sprintf("DC after: %+v", ev))
attrsDC := &utils.AttrDerivedChargers{Tenant: ev.GetTenant(utils.META_DEFAULT), Category: ev.GetCategory(utils.META_DEFAULT), Direction: ev.GetDirection(utils.META_DEFAULT),
Account: ev.GetAccount(utils.META_DEFAULT), Subject: ev.GetSubject(utils.META_DEFAULT), Destination: ev.GetDestination(utils.META_DEFAULT)}
//utils.Logger.Info(fmt.Sprintf("Derived chargers for: %+v", attrsDC))
dcs := &utils.DerivedChargers{}
if err := rs.GetDerivedChargers(attrsDC, dcs); err != nil {
rs.getCache().Cache(cacheKey, &CacheItem{
Err: err,
})
return err
}
dcs, _ = dcs.AppendDefaultRun()
//utils.Logger.Info(fmt.Sprintf("DCS: %v", len(dcs.Chargers)))
sesRuns := make([]*SessionRun, 0)
for _, dc := range dcs.Chargers {
if !utils.IsSliceMember([]string{utils.META_PREPAID, utils.PREPAID}, ev.GetReqType(dc.RequestTypeField)) {
continue // We only consider prepaid sessions
}
startTime, err := ev.GetAnswerTime(dc.AnswerTimeField, rs.Timezone)
if err != nil {
rs.getCache().Cache(cacheKey, &CacheItem{Err: err})
return errors.New("Error parsing answer event start time")
}
endTime, err := ev.GetEndTime("", rs.Timezone)
if err != nil {
rs.getCache().Cache(cacheKey, &CacheItem{Err: err})
return errors.New("Error parsing answer event end time")
}
extraFields := ev.GetExtraFields()
cd := &CallDescriptor{
CgrID: ev.GetCgrId(rs.Timezone),
RunID: dc.RunID,
TOR: ev.ToR,
Direction: ev.GetDirection(dc.DirectionField),
Tenant: ev.GetTenant(dc.TenantField),
Category: ev.GetCategory(dc.CategoryField),
Subject: ev.GetSubject(dc.SubjectField),
Account: ev.GetAccount(dc.AccountField),
Destination: ev.GetDestination(dc.DestinationField),
TimeStart: startTime,
TimeEnd: endTime,
ExtraFields: extraFields}
if flagsStr, hasFlags := extraFields[utils.CGRFlags]; hasFlags { // Force duration from extra fields
flags := utils.StringMapFromSlice(strings.Split(flagsStr, utils.INFIELD_SEP))
if _, hasFD := flags[utils.FlagForceDuration]; hasFD {
cd.ForceDuration = true
}
}
sesRuns = append(sesRuns, &SessionRun{DerivedCharger: dc, CallDescriptor: cd})
}
//utils.Logger.Info(fmt.Sprintf("RUNS: %v", len(sesRuns)))
*sRuns = sesRuns
rs.getCache().Cache(cacheKey, &CacheItem{Value: sRuns})
return nil
}
func (self *SmGenericConfig) loadFromJsonCfg(jsnCfg *SmGenericJsonCfg) error {
if jsnCfg == nil {
return nil
}
var err error
if jsnCfg.Enabled != nil {
self.Enabled = *jsnCfg.Enabled
}
if jsnCfg.Listen_bijson != nil {
self.ListenBijson = *jsnCfg.Listen_bijson
}
if jsnCfg.Rals_conns != nil {
self.RALsConns = make([]*HaPoolConfig, len(*jsnCfg.Rals_conns))
for idx, jsnHaCfg := range *jsnCfg.Rals_conns {
self.RALsConns[idx] = NewDfltHaPoolConfig()
self.RALsConns[idx].loadFromJsonCfg(jsnHaCfg)
}
}
if jsnCfg.Cdrs_conns != nil {
self.CDRsConns = make([]*HaPoolConfig, len(*jsnCfg.Cdrs_conns))
for idx, jsnHaCfg := range *jsnCfg.Cdrs_conns {
self.CDRsConns[idx] = NewDfltHaPoolConfig()
self.CDRsConns[idx].loadFromJsonCfg(jsnHaCfg)
}
}
if jsnCfg.Smg_replication_conns != nil {
self.SMGReplicationConns = make([]*HaPoolConfig, len(*jsnCfg.Smg_replication_conns))
for idx, jsnHaCfg := range *jsnCfg.Smg_replication_conns {
self.SMGReplicationConns[idx] = NewDfltHaPoolConfig()
self.SMGReplicationConns[idx].loadFromJsonCfg(jsnHaCfg)
}
}
if jsnCfg.Debit_interval != nil {
if self.DebitInterval, err = utils.ParseDurationWithSecs(*jsnCfg.Debit_interval); err != nil {
return err
}
}
if jsnCfg.Min_call_duration != nil {
if self.MinCallDuration, err = utils.ParseDurationWithSecs(*jsnCfg.Min_call_duration); err != nil {
return err
}
}
if jsnCfg.Max_call_duration != nil {
if self.MaxCallDuration, err = utils.ParseDurationWithSecs(*jsnCfg.Max_call_duration); err != nil {
return err
}
}
if jsnCfg.Session_ttl != nil {
if self.SessionTTL, err = utils.ParseDurationWithSecs(*jsnCfg.Session_ttl); err != nil {
return err
}
}
if jsnCfg.Session_ttl_last_used != nil {
if sessionTTLLastUsed, err := utils.ParseDurationWithSecs(*jsnCfg.Session_ttl_last_used); err != nil {
return err
} else {
self.SessionTTLLastUsed = &sessionTTLLastUsed
}
}
if jsnCfg.Session_indexes != nil {
self.SessionIndexes = utils.StringMapFromSlice(*jsnCfg.Session_indexes)
}
return nil
}