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

Updated APIs for gob RPC

Browse Source
This commit is contained in:
Trial97
2019-11-26 16:17:16 +02:00
parent 899cd38035
commit 3e54da517a
12 changed files with 474 additions and 421 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
apier/v1/accounts.go
View File

@@ -508,7 +508,7 @@ func (self *ApierV1) modifyBalance(aType string, attr *AttrAddBalance, reply *st
ActionType: utils.MetaPublishBalance,
}
acts := engine.Actions{a, publishAction}
if attr.Cdrlog != nil && *attr.Cdrlog == true {
if attr.Cdrlog != nil && *attr.Cdrlog {
acts = engine.Actions{a, publishAction, &engine.Action{
ActionType: utils.CDRLOG,
}}
@@ -603,7 +603,7 @@ func (self *ApierV1) SetBalance(attr *utils.AttrSetBalance, reply *string) error
ActionType: utils.MetaPublishBalance,
}
acts := engine.Actions{a, publishAction}
if attr.Cdrlog != nil && *attr.Cdrlog == true {
if attr.Cdrlog != nil && *attr.Cdrlog {
acts = engine.Actions{a, publishAction, &engine.Action{
ActionType: utils.CDRLOG,
}}

2
apier/v1/apier.go
View File

@@ -92,7 +92,7 @@ func (apiv1 *ApierV1) RemoveDestination(attr AttrRemoveDestination, reply *strin
// set destinastion
}
}
return err
return
}
// GetReverseDestination retrieves revese destination list for a prefix

36
apier/v1/cdre.go
View File

@@ -39,11 +39,11 @@ import (
"github.com/cgrates/cgrates/utils"
)
func (self *ApierV1) ExportCdrsToZipString(attr utils.AttrExpFileCdrs, reply *string) error {
func (api *ApierV1) ExportCdrsToZipString(attr utils.AttrExpFileCdrs, reply *string) error {
tmpDir := "/tmp"
attr.ExportDir = &tmpDir // Enforce exporting to tmp always so we avoid cleanup issues
efc := utils.ExportedFileCdrs{}
if err := self.ExportCdrsToFile(attr, &efc); err != nil {
if err := api.ExportCdrsToFile(attr, &efc); err != nil {
return err
} else if efc.TotalRecords == 0 || len(efc.ExportedFilePath) == 0 {
return errors.New("No CDR records to export")
@@ -92,11 +92,11 @@ func (self *ApierV1) ExportCdrsToZipString(attr utils.AttrExpFileCdrs, reply *st
}
// Deprecated by AttrExportCDRsToFile
func (self *ApierV1) ExportCdrsToFile(attr utils.AttrExpFileCdrs, reply *utils.ExportedFileCdrs) (err error) {
exportTemplate := self.Config.CdreProfiles[utils.META_DEFAULT]
func (api *ApierV1) ExportCdrsToFile(attr utils.AttrExpFileCdrs, reply *utils.ExportedFileCdrs) (err error) {
exportTemplate := api.Config.CdreProfiles[utils.META_DEFAULT]
if attr.ExportTemplate != nil && len(*attr.ExportTemplate) != 0 { // Export template prefered, use it
var hasIt bool
if exportTemplate, hasIt = self.Config.CdreProfiles[*attr.ExportTemplate]; !hasIt {
if exportTemplate, hasIt = api.Config.CdreProfiles[*attr.ExportTemplate]; !hasIt {
return fmt.Errorf("%s:ExportTemplate", utils.ErrNotFound.Error())
}
}
@@ -133,11 +133,11 @@ func (self *ApierV1) ExportCdrsToFile(attr utils.AttrExpFileCdrs, reply *utils.E
if exportFormat == utils.DRYRUN {
filePath = utils.DRYRUN
}
cdrsFltr, err := attr.AsCDRsFilter(self.Config.GeneralCfg().DefaultTimezone)
cdrsFltr, err := attr.AsCDRsFilter(api.Config.GeneralCfg().DefaultTimezone)
if err != nil {
return utils.NewErrServerError(err)
}
cdrs, _, err := self.CdrDb.GetCDRs(cdrsFltr, false)
cdrs, _, err := api.CdrDb.GetCDRs(cdrsFltr, false)
if err != nil {
return err
} else if len(cdrs) == 0 {
@@ -147,8 +147,8 @@ func (self *ApierV1) ExportCdrsToFile(attr utils.AttrExpFileCdrs, reply *utils.E
cdrexp, err := engine.NewCDRExporter(cdrs, exportTemplate, exportFormat,
filePath, utils.META_NONE, exportID, exportTemplate.Synchronous,
exportTemplate.Attempts, fieldSep,
self.Config.GeneralCfg().HttpSkipTlsVerify, self.HTTPPoster,
self.AttributeS, self.FilterS)
api.Config.GeneralCfg().HttpSkipTlsVerify, api.HTTPPoster,
api.AttributeS, api.FilterS)
if err != nil {
return utils.NewErrServerError(err)
}
@@ -211,13 +211,13 @@ type RplExportedCDRs struct {
}
// ExportCDRs exports CDRs on a path (file or remote)
func (self *ApierV1) ExportCDRs(arg ArgExportCDRs, reply *RplExportedCDRs) (err error) {
cdreReloadStruct := <-self.Config.ConfigReloads[utils.CDRE] // Read the content of the channel, locking it
defer func() { self.Config.ConfigReloads[utils.CDRE] <- cdreReloadStruct }() // Unlock reloads at exit
exportTemplate := self.Config.CdreProfiles[utils.META_DEFAULT]
func (api *ApierV1) ExportCDRs(arg ArgExportCDRs, reply *RplExportedCDRs) (err error) {
cdreReloadStruct := <-api.Config.ConfigReloads[utils.CDRE] // Read the content of the channel, locking it
defer func() { api.Config.ConfigReloads[utils.CDRE] <- cdreReloadStruct }() // Unlock reloads at exit
exportTemplate := api.Config.CdreProfiles[utils.META_DEFAULT]
if arg.ExportTemplate != nil && len(*arg.ExportTemplate) != 0 { // Export template prefered, use it
var hasIt bool
if exportTemplate, hasIt = self.Config.CdreProfiles[*arg.ExportTemplate]; !hasIt {
if exportTemplate, hasIt = api.Config.CdreProfiles[*arg.ExportTemplate]; !hasIt {
return fmt.Errorf("%s:ExportTemplate", utils.ErrNotFound)
}
}
@@ -275,11 +275,11 @@ func (self *ApierV1) ExportCDRs(arg ArgExportCDRs, reply *RplExportedCDRs) (err
u.Path = path.Join(u.Path, fileName)
filePath = u.String()
}
cdrsFltr, err := arg.RPCCDRsFilter.AsCDRsFilter(self.Config.GeneralCfg().DefaultTimezone)
cdrsFltr, err := arg.RPCCDRsFilter.AsCDRsFilter(api.Config.GeneralCfg().DefaultTimezone)
if err != nil {
return utils.NewErrServerError(err)
}
cdrs, _, err := self.CdrDb.GetCDRs(cdrsFltr, false)
cdrs, _, err := api.CdrDb.GetCDRs(cdrsFltr, false)
if err != nil {
return err
} else if len(cdrs) == 0 {
@@ -288,8 +288,8 @@ func (self *ApierV1) ExportCDRs(arg ArgExportCDRs, reply *RplExportedCDRs) (err
cdrexp, err := engine.NewCDRExporter(cdrs, exportTemplate, exportFormat,
filePath, utils.META_NONE, exportID,
synchronous, attempts, fieldSep,
self.Config.GeneralCfg().HttpSkipTlsVerify,
self.HTTPPoster, self.AttributeS, self.FilterS)
api.Config.GeneralCfg().HttpSkipTlsVerify,
api.HTTPPoster, api.AttributeS, api.FilterS)
if err != nil {
return utils.NewErrServerError(err)
}

347
apier/v1/filter_indexes.go
View File

@@ -42,7 +42,7 @@ type AttrRemFilterIndexes struct {
ItemType string
}
func (self *ApierV1) RemoveFilterIndexes(arg AttrRemFilterIndexes, reply *string) (err error) {
func (api *ApierV1) RemoveFilterIndexes(arg AttrRemFilterIndexes, reply *string) (err error) {
if missing := utils.MissingStructFields(&arg, []string{"Tenant", "ItemType"}); len(missing) != 0 { //Params missing
return utils.NewErrMandatoryIeMissing(missing...)
}
@@ -71,14 +71,14 @@ func (self *ApierV1) RemoveFilterIndexes(arg AttrRemFilterIndexes, reply *string
arg.ItemType = utils.AttributeProfilePrefix
key = utils.ConcatenatedKey(arg.Tenant, arg.Context)
}
if err = self.DataManager.RemoveFilterIndexes(utils.PrefixToIndexCache[arg.ItemType], key); err != nil {
if err = api.DataManager.RemoveFilterIndexes(utils.PrefixToIndexCache[arg.ItemType], key); err != nil {
return err
}
*reply = utils.OK
return nil
}
func (self *ApierV1) GetFilterIndexes(arg AttrGetFilterIndexes, reply *[]string) (err error) {
func (api *ApierV1) GetFilterIndexes(arg AttrGetFilterIndexes, reply *[]string) (err error) {
var indexes map[string]utils.StringMap
var indexedSlice []string
indexesFilter := make(map[string]utils.StringMap)
@@ -110,7 +110,7 @@ func (self *ApierV1) GetFilterIndexes(arg AttrGetFilterIndexes, reply *[]string)
arg.ItemType = utils.AttributeProfilePrefix
key = utils.ConcatenatedKey(arg.Tenant, arg.Context)
}
if indexes, err = self.DataManager.GetFilterIndexes(
if indexes, err = api.DataManager.GetFilterIndexes(
utils.PrefixToIndexCache[arg.ItemType], key, "", nil); err != nil {
return err
}
@@ -200,40 +200,40 @@ func (self *ApierV1) GetFilterIndexes(arg AttrGetFilterIndexes, reply *[]string)
return nil
}
func (self *ApierV1) ComputeFilterIndexes(args utils.ArgsComputeFilterIndexes, reply *string) error {
func (api *ApierV1) ComputeAllFilterIndexes(args utils.ArgsComputeFilterIndexes, reply *string) (err error) {
transactionID := utils.GenUUID()
//ThresholdProfile Indexes
thdsIndexers, err := self.computeThresholdIndexes(args.Tenant, args.ThresholdIDs, transactionID)
thdsIndexers, err := api.computeThresholdIndexes(args.Tenant, nil, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//StatQueueProfile Indexes
sqpIndexers, err := self.computeStatIndexes(args.Tenant, args.StatIDs, transactionID)
sqpIndexers, err := api.computeStatIndexes(args.Tenant, nil, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//ResourceProfile Indexes
rsIndexes, err := self.computeResourceIndexes(args.Tenant, args.ResourceIDs, transactionID)
rsIndexes, err := api.computeResourceIndexes(args.Tenant, nil, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//SupplierProfile Indexes
sppIndexes, err := self.computeSupplierIndexes(args.Tenant, args.SupplierIDs, transactionID)
sppIndexes, err := api.computeSupplierIndexes(args.Tenant, nil, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//AttributeProfile Indexes
attrIndexes, err := self.computeAttributeIndexes(args.Tenant, args.Context, args.AttributeIDs, transactionID)
attrIndexes, err := api.computeAttributeIndexes(args.Tenant, args.Context, nil, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//ChargerProfile Indexes
cppIndexes, err := self.computeChargerIndexes(args.Tenant, args.ChargerIDs, transactionID)
cppIndexes, err := api.computeChargerIndexes(args.Tenant, nil, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//DispatcherProfile Indexes
dspIndexes, err := self.computeDispatcherIndexes(args.Tenant, args.Context, args.DispatcherIDs, transactionID)
dspIndexes, err := api.computeDispatcherIndexes(args.Tenant, args.Context, nil, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
@@ -241,133 +241,204 @@ func (self *ApierV1) ComputeFilterIndexes(args utils.ArgsComputeFilterIndexes, r
//Now we move from tmpKey to the right key for each type
//ThresholdProfile Indexes
if thdsIndexers != nil {
if err := thdsIndexers.StoreIndexes(true, transactionID); err != nil {
if args.ThresholdIDs != nil {
for _, id := range *args.ThresholdIDs {
th, err := self.DataManager.GetThresholdProfile(args.Tenant, id, true, false, utils.NonTransactional)
if err != nil {
return err
}
if err := thdsIndexers.RemoveItemFromIndex(args.Tenant, id, th.FilterIDs); err != nil {
return err
}
}
}
return err
if err = thdsIndexers.StoreIndexes(true, transactionID); err != nil {
return
}
}
//StatQueueProfile Indexes
if sqpIndexers != nil {
if err := sqpIndexers.StoreIndexes(true, transactionID); err != nil {
if args.StatIDs != nil {
for _, id := range *args.StatIDs {
sqp, err := self.DataManager.GetStatQueueProfile(args.Tenant, id, true, false, utils.NonTransactional)
if err != nil {
return err
}
if err := sqpIndexers.RemoveItemFromIndex(args.Tenant, id, sqp.FilterIDs); err != nil {
return err
}
}
}
return err
if err = sqpIndexers.StoreIndexes(true, transactionID); err != nil {
return
}
}
//ResourceProfile Indexes
if rsIndexes != nil {
if err := rsIndexes.StoreIndexes(true, transactionID); err != nil {
if args.ResourceIDs != nil {
for _, id := range *args.ResourceIDs {
rp, err := self.DataManager.GetResourceProfile(args.Tenant, id, true, false, utils.NonTransactional)
if err != nil {
return err
}
if err := rsIndexes.RemoveItemFromIndex(args.Tenant, id, rp.FilterIDs); err != nil {
return err
}
}
}
return err
if err = rsIndexes.StoreIndexes(true, transactionID); err != nil {
return
}
}
//SupplierProfile Indexes
if sppIndexes != nil {
if err := sppIndexes.StoreIndexes(true, transactionID); err != nil {
if args.SupplierIDs != nil {
for _, id := range *args.SupplierIDs {
spp, err := self.DataManager.GetSupplierProfile(args.Tenant, id, true, false, utils.NonTransactional)
if err != nil {
return err
}
if err := sppIndexes.RemoveItemFromIndex(args.Tenant, id, spp.FilterIDs); err != nil {
return err
}
}
}
return err
if err = sppIndexes.StoreIndexes(true, transactionID); err != nil {
return
}
}
//AttributeProfile Indexes
if attrIndexes != nil {
if err := attrIndexes.StoreIndexes(true, transactionID); err != nil {
if args.AttributeIDs != nil {
for _, id := range *args.AttributeIDs {
ap, err := self.DataManager.GetAttributeProfile(args.Tenant, id, true, false, utils.NonTransactional)
if err != nil {
return err
}
if err := attrIndexes.RemoveItemFromIndex(args.Tenant, id, ap.FilterIDs); err != nil {
return err
}
}
}
return err
if err = attrIndexes.StoreIndexes(true, transactionID); err != nil {
return
}
}
//ChargerProfile Indexes
if cppIndexes != nil {
if err := cppIndexes.StoreIndexes(true, transactionID); err != nil {
if args.ChargerIDs != nil {
for _, id := range *args.ChargerIDs {
cpp, err := self.DataManager.GetChargerProfile(args.Tenant, id, true, false, utils.NonTransactional)
if err != nil {
return err
}
if err := cppIndexes.RemoveItemFromIndex(args.Tenant, id, cpp.FilterIDs); err != nil {
return err
}
}
}
return err
if err = cppIndexes.StoreIndexes(true, transactionID); err != nil {
return
}
}
//DispatcherProfile Indexes
if dspIndexes != nil {
if err := dspIndexes.StoreIndexes(true, transactionID); err != nil {
if args.DispatcherIDs != nil {
for _, id := range *args.DispatcherIDs {
cpp, err := self.DataManager.GetDispatcherProfile(args.Tenant, id, true, false, utils.NonTransactional)
if err != nil {
return err
}
if err := dspIndexes.RemoveItemFromIndex(args.Tenant, id, cpp.FilterIDs); err != nil {
return err
}
}
}
return err
if err = dspIndexes.StoreIndexes(true, transactionID); err != nil {
return
}
}
*reply = utils.OK
return nil
}
func (self *ApierV1) computeThresholdIndexes(tenant string, thIDs *[]string,
func (api *ApierV1) ComputeFilterIndexes(args utils.ArgsComputeFilterIndexIDs, reply *string) (err error) {
transactionID := utils.GenUUID()
//ThresholdProfile Indexes
thdsIndexers, err := api.computeThresholdIndexes(args.Tenant, &args.ThresholdIDs, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//StatQueueProfile Indexes
sqpIndexers, err := api.computeStatIndexes(args.Tenant, &args.StatIDs, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//ResourceProfile Indexes
rsIndexes, err := api.computeResourceIndexes(args.Tenant, &args.ResourceIDs, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//SupplierProfile Indexes
sppIndexes, err := api.computeSupplierIndexes(args.Tenant, &args.SupplierIDs, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//AttributeProfile Indexes
attrIndexes, err := api.computeAttributeIndexes(args.Tenant, args.Context, &args.AttributeIDs, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//ChargerProfile Indexes
cppIndexes, err := api.computeChargerIndexes(args.Tenant, &args.ChargerIDs, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//DispatcherProfile Indexes
dspIndexes, err := api.computeDispatcherIndexes(args.Tenant, args.Context, &args.DispatcherIDs, transactionID)
if err != nil && err != utils.ErrNotFound {
return utils.APIErrorHandler(err)
}
//Now we move from tmpKey to the right key for each type
//ThresholdProfile Indexes
if thdsIndexers != nil {
if err = thdsIndexers.StoreIndexes(true, transactionID); err != nil {
for _, id := range args.ThresholdIDs {
var th *engine.ThresholdProfile
if th, err = api.DataManager.GetThresholdProfile(args.Tenant, id, true, false, utils.NonTransactional); err != nil {
return
}
if err = thdsIndexers.RemoveItemFromIndex(args.Tenant, id, th.FilterIDs); err != nil {
return
}
}
return
}
}
//StatQueueProfile Indexes
if sqpIndexers != nil {
if err = sqpIndexers.StoreIndexes(true, transactionID); err != nil {
for _, id := range args.StatIDs {
var sqp *engine.StatQueueProfile
if sqp, err = api.DataManager.GetStatQueueProfile(args.Tenant, id, true, false, utils.NonTransactional); err != nil {
return
}
if err = sqpIndexers.RemoveItemFromIndex(args.Tenant, id, sqp.FilterIDs); err != nil {
return
}
}
return
}
}
//ResourceProfile Indexes
if rsIndexes != nil {
if err = rsIndexes.StoreIndexes(true, transactionID); err != nil {
for _, id := range args.ResourceIDs {
var rp *engine.ResourceProfile
if rp, err = api.DataManager.GetResourceProfile(args.Tenant, id, true, false, utils.NonTransactional); err != nil {
return
}
if err = rsIndexes.RemoveItemFromIndex(args.Tenant, id, rp.FilterIDs); err != nil {
return
}
}
return
}
}
//SupplierProfile Indexes
if sppIndexes != nil {
if err = sppIndexes.StoreIndexes(true, transactionID); err != nil {
for _, id := range args.SupplierIDs {
var spp *engine.SupplierProfile
if spp, err = api.DataManager.GetSupplierProfile(args.Tenant, id, true, false, utils.NonTransactional); err != nil {
return
}
if err = sppIndexes.RemoveItemFromIndex(args.Tenant, id, spp.FilterIDs); err != nil {
return
}
}
return
}
}
//AttributeProfile Indexes
if attrIndexes != nil {
if err = attrIndexes.StoreIndexes(true, transactionID); err != nil {
for _, id := range args.AttributeIDs {
var ap *engine.AttributeProfile
if ap, err = api.DataManager.GetAttributeProfile(args.Tenant, id, true, false, utils.NonTransactional); err != nil {
return
}
if err = attrIndexes.RemoveItemFromIndex(args.Tenant, id, ap.FilterIDs); err != nil {
return
}
}
return
}
}
//ChargerProfile Indexes
if cppIndexes != nil {
if err = cppIndexes.StoreIndexes(true, transactionID); err != nil {
for _, id := range args.ChargerIDs {
var cpp *engine.ChargerProfile
if cpp, err = api.DataManager.GetChargerProfile(args.Tenant, id, true, false, utils.NonTransactional); err != nil {
return
}
if err = cppIndexes.RemoveItemFromIndex(args.Tenant, id, cpp.FilterIDs); err != nil {
return
}
}
return
}
}
//DispatcherProfile Indexes
if dspIndexes != nil {
if err = dspIndexes.StoreIndexes(true, transactionID); err != nil {
for _, id := range args.DispatcherIDs {
var dpp *engine.DispatcherProfile
if dpp, err = api.DataManager.GetDispatcherProfile(args.Tenant, id, true, false, utils.NonTransactional); err != nil {
return
}
if err = dspIndexes.RemoveItemFromIndex(args.Tenant, id, dpp.FilterIDs); err != nil {
return
}
}
return
}
}
*reply = utils.OK
return nil
}
func (api *ApierV1) computeThresholdIndexes(tenant string, thIDs *[]string,
transactionID string) (filterIndexer *engine.FilterIndexer, err error) {
var thresholdIDs []string
thdsIndexers := engine.NewFilterIndexer(self.DataManager, utils.ThresholdProfilePrefix, tenant)
thdsIndexers := engine.NewFilterIndexer(api.DataManager, utils.ThresholdProfilePrefix, tenant)
if thIDs == nil {
ids, err := self.DataManager.DataDB().GetKeysForPrefix(utils.ThresholdProfilePrefix)
ids, err := api.DataManager.DataDB().GetKeysForPrefix(utils.ThresholdProfilePrefix)
if err != nil {
return nil, err
}
@@ -379,7 +450,7 @@ func (self *ApierV1) computeThresholdIndexes(tenant string, thIDs *[]string,
transactionID = utils.NonTransactional
}
for _, id := range thresholdIDs {
th, err := self.DataManager.GetThresholdProfile(tenant, id, true, false, utils.NonTransactional)
th, err := api.DataManager.GetThresholdProfile(tenant, id, true, false, utils.NonTransactional)
if err != nil {
return nil, err
}
@@ -404,7 +475,7 @@ func (self *ApierV1) computeThresholdIndexes(tenant string, thIDs *[]string,
},
},
}
} else if fltr, err = self.DataManager.GetFilter(th.Tenant, fltrID,
} else if fltr, err = api.DataManager.GetFilter(th.Tenant, fltrID,
true, false, utils.NonTransactional); err != nil {
if err == utils.ErrNotFound {
err = fmt.Errorf("broken reference to filter: %+v for threshold: %+v",
@@ -428,13 +499,13 @@ func (self *ApierV1) computeThresholdIndexes(tenant string, thIDs *[]string,
return thdsIndexers, nil
}
func (self *ApierV1) computeAttributeIndexes(tenant, context string, attrIDs *[]string,
func (api *ApierV1) computeAttributeIndexes(tenant, context string, attrIDs *[]string,
transactionID string) (filterIndexer *engine.FilterIndexer, err error) {
var attributeIDs []string
attrIndexers := engine.NewFilterIndexer(self.DataManager, utils.AttributeProfilePrefix,
attrIndexers := engine.NewFilterIndexer(api.DataManager, utils.AttributeProfilePrefix,
utils.ConcatenatedKey(tenant, context))
if attrIDs == nil {
ids, err := self.DataManager.DataDB().GetKeysForPrefix(utils.AttributeProfilePrefix)
ids, err := api.DataManager.DataDB().GetKeysForPrefix(utils.AttributeProfilePrefix)
if err != nil {
return nil, err
}
@@ -446,7 +517,7 @@ func (self *ApierV1) computeAttributeIndexes(tenant, context string, attrIDs *[]
transactionID = utils.NonTransactional
}
for _, id := range attributeIDs {
ap, err := self.DataManager.GetAttributeProfile(tenant, id, true, false, utils.NonTransactional)
ap, err := api.DataManager.GetAttributeProfile(tenant, id, true, false, utils.NonTransactional)
if err != nil {
return nil, err
}
@@ -474,7 +545,7 @@ func (self *ApierV1) computeAttributeIndexes(tenant, context string, attrIDs *[]
},
},
}
} else if fltr, err = self.DataManager.GetFilter(ap.Tenant, fltrID,
} else if fltr, err = api.DataManager.GetFilter(ap.Tenant, fltrID,
true, false, utils.NonTransactional); err != nil {
if err == utils.ErrNotFound {
err = fmt.Errorf("broken reference to filter: %+v for attribute: %+v",
@@ -498,12 +569,12 @@ func (self *ApierV1) computeAttributeIndexes(tenant, context string, attrIDs *[]
return attrIndexers, nil
}
func (self *ApierV1) computeResourceIndexes(tenant string, rsIDs *[]string,
func (api *ApierV1) computeResourceIndexes(tenant string, rsIDs *[]string,
transactionID string) (filterIndexer *engine.FilterIndexer, err error) {
var resourceIDs []string
rpIndexers := engine.NewFilterIndexer(self.DataManager, utils.ResourceProfilesPrefix, tenant)
rpIndexers := engine.NewFilterIndexer(api.DataManager, utils.ResourceProfilesPrefix, tenant)
if rsIDs == nil {
ids, err := self.DataManager.DataDB().GetKeysForPrefix(utils.ResourceProfilesPrefix)
ids, err := api.DataManager.DataDB().GetKeysForPrefix(utils.ResourceProfilesPrefix)
if err != nil {
return nil, err
}
@@ -515,7 +586,7 @@ func (self *ApierV1) computeResourceIndexes(tenant string, rsIDs *[]string,
transactionID = utils.NonTransactional
}
for _, id := range resourceIDs {
rp, err := self.DataManager.GetResourceProfile(tenant, id, true, false, utils.NonTransactional)
rp, err := api.DataManager.GetResourceProfile(tenant, id, true, false, utils.NonTransactional)
if err != nil {
return nil, err
}
@@ -540,7 +611,7 @@ func (self *ApierV1) computeResourceIndexes(tenant string, rsIDs *[]string,
},
},
}
} else if fltr, err = self.DataManager.GetFilter(rp.Tenant, fltrID,
} else if fltr, err = api.DataManager.GetFilter(rp.Tenant, fltrID,
true, false, utils.NonTransactional); err != nil {
if err == utils.ErrNotFound {
err = fmt.Errorf("broken reference to filter: %+v for resource: %+v",
@@ -564,12 +635,12 @@ func (self *ApierV1) computeResourceIndexes(tenant string, rsIDs *[]string,
return rpIndexers, nil
}
func (self *ApierV1) computeStatIndexes(tenant string, stIDs *[]string,
func (api *ApierV1) computeStatIndexes(tenant string, stIDs *[]string,
transactionID string) (filterIndexer *engine.FilterIndexer, err error) {
var statIDs []string
sqpIndexers := engine.NewFilterIndexer(self.DataManager, utils.StatQueueProfilePrefix, tenant)
sqpIndexers := engine.NewFilterIndexer(api.DataManager, utils.StatQueueProfilePrefix, tenant)
if stIDs == nil {
ids, err := self.DataManager.DataDB().GetKeysForPrefix(utils.StatQueueProfilePrefix)
ids, err := api.DataManager.DataDB().GetKeysForPrefix(utils.StatQueueProfilePrefix)
if err != nil {
return nil, err
}
@@ -581,7 +652,7 @@ func (self *ApierV1) computeStatIndexes(tenant string, stIDs *[]string,
transactionID = utils.NonTransactional
}
for _, id := range statIDs {
sqp, err := self.DataManager.GetStatQueueProfile(tenant, id, true, false, utils.NonTransactional)
sqp, err := api.DataManager.GetStatQueueProfile(tenant, id, true, false, utils.NonTransactional)
if err != nil {
return nil, err
}
@@ -606,7 +677,7 @@ func (self *ApierV1) computeStatIndexes(tenant string, stIDs *[]string,
},
},
}
} else if fltr, err = self.DataManager.GetFilter(sqp.Tenant, fltrID,
} else if fltr, err = api.DataManager.GetFilter(sqp.Tenant, fltrID,
true, false, utils.NonTransactional); err != nil {
if err == utils.ErrNotFound {
err = fmt.Errorf("broken reference to filter: %+v for statqueue: %+v",
@@ -630,12 +701,12 @@ func (self *ApierV1) computeStatIndexes(tenant string, stIDs *[]string,
return sqpIndexers, nil
}
func (self *ApierV1) computeSupplierIndexes(tenant string, sppIDs *[]string,
func (api *ApierV1) computeSupplierIndexes(tenant string, sppIDs *[]string,
transactionID string) (filterIndexer *engine.FilterIndexer, err error) {
var supplierIDs []string
sppIndexers := engine.NewFilterIndexer(self.DataManager, utils.SupplierProfilePrefix, tenant)
sppIndexers := engine.NewFilterIndexer(api.DataManager, utils.SupplierProfilePrefix, tenant)
if sppIDs == nil {
ids, err := self.DataManager.DataDB().GetKeysForPrefix(utils.SupplierProfilePrefix)
ids, err := api.DataManager.DataDB().GetKeysForPrefix(utils.SupplierProfilePrefix)
if err != nil {
return nil, err
}
@@ -647,7 +718,7 @@ func (self *ApierV1) computeSupplierIndexes(tenant string, sppIDs *[]string,
transactionID = utils.NonTransactional
}
for _, id := range supplierIDs {
spp, err := self.DataManager.GetSupplierProfile(tenant, id, true, false, utils.NonTransactional)
spp, err := api.DataManager.GetSupplierProfile(tenant, id, true, false, utils.NonTransactional)
if err != nil {
return nil, err
}
@@ -672,7 +743,7 @@ func (self *ApierV1) computeSupplierIndexes(tenant string, sppIDs *[]string,
},
},
}
} else if fltr, err = self.DataManager.GetFilter(spp.Tenant, fltrID,
} else if fltr, err = api.DataManager.GetFilter(spp.Tenant, fltrID,
true, false, utils.NonTransactional); err != nil {
if err == utils.ErrNotFound {
err = fmt.Errorf("broken reference to filter: %+v for suppliers: %+v",
@@ -696,12 +767,12 @@ func (self *ApierV1) computeSupplierIndexes(tenant string, sppIDs *[]string,
return sppIndexers, nil
}
func (self *ApierV1) computeChargerIndexes(tenant string, cppIDs *[]string,
func (api *ApierV1) computeChargerIndexes(tenant string, cppIDs *[]string,
transactionID string) (filterIndexer *engine.FilterIndexer, err error) {
var chargerIDs []string
cppIndexes := engine.NewFilterIndexer(self.DataManager, utils.ChargerProfilePrefix, tenant)
cppIndexes := engine.NewFilterIndexer(api.DataManager, utils.ChargerProfilePrefix, tenant)
if cppIDs == nil {
ids, err := self.DataManager.DataDB().GetKeysForPrefix(utils.ChargerProfilePrefix)
ids, err := api.DataManager.DataDB().GetKeysForPrefix(utils.ChargerProfilePrefix)
if err != nil {
return nil, err
}
@@ -713,7 +784,7 @@ func (self *ApierV1) computeChargerIndexes(tenant string, cppIDs *[]string,
transactionID = utils.NonTransactional
}
for _, id := range chargerIDs {
cpp, err := self.DataManager.GetChargerProfile(tenant, id, true, false, utils.NonTransactional)
cpp, err := api.DataManager.GetChargerProfile(tenant, id, true, false, utils.NonTransactional)
if err != nil {
return nil, err
}
@@ -738,7 +809,7 @@ func (self *ApierV1) computeChargerIndexes(tenant string, cppIDs *[]string,
},
},
}
} else if fltr, err = self.DataManager.GetFilter(cpp.Tenant, fltrID,
} else if fltr, err = api.DataManager.GetFilter(cpp.Tenant, fltrID,
true, false, utils.NonTransactional); err != nil {
if err == utils.ErrNotFound {
err = fmt.Errorf("broken reference to filter: %+v for charger: %+v",
@@ -762,13 +833,13 @@ func (self *ApierV1) computeChargerIndexes(tenant string, cppIDs *[]string,
return cppIndexes, nil
}
func (self *ApierV1) computeDispatcherIndexes(tenant, context string, dspIDs *[]string,
func (api *ApierV1) computeDispatcherIndexes(tenant, context string, dspIDs *[]string,
transactionID string) (filterIndexer *engine.FilterIndexer, err error) {
var dispatcherIDs []string
dspIndexes := engine.NewFilterIndexer(self.DataManager, utils.DispatcherProfilePrefix,
dspIndexes := engine.NewFilterIndexer(api.DataManager, utils.DispatcherProfilePrefix,
utils.ConcatenatedKey(tenant, context))
if dspIDs == nil {
ids, err := self.DataManager.DataDB().GetKeysForPrefix(utils.DispatcherProfilePrefix)
ids, err := api.DataManager.DataDB().GetKeysForPrefix(utils.DispatcherProfilePrefix)
if err != nil {
return nil, err
}
@@ -780,7 +851,7 @@ func (self *ApierV1) computeDispatcherIndexes(tenant, context string, dspIDs *[]
transactionID = utils.NonTransactional
}
for _, id := range dispatcherIDs {
dsp, err := self.DataManager.GetDispatcherProfile(tenant, id, true, false, utils.NonTransactional)
dsp, err := api.DataManager.GetDispatcherProfile(tenant, id, true, false, utils.NonTransactional)
if err != nil {
return nil, err
}
@@ -808,7 +879,7 @@ func (self *ApierV1) computeDispatcherIndexes(tenant, context string, dspIDs *[]
},
},
}
} else if fltr, err = self.DataManager.GetFilter(dsp.Tenant, fltrID,
} else if fltr, err = api.DataManager.GetFilter(dsp.Tenant, fltrID,
true, false, utils.NonTransactional); err != nil {
if err == utils.ErrNotFound {
err = fmt.Errorf("broken reference to filter: %+v for dispatcher: %+v",

40
apier/v1/filter_indexes_it_test.go
View File

@@ -227,7 +227,7 @@ func testV1FIdxSetThresholdProfile(t *testing.T) {
func testV1FIdxComputeThresholdsIndexes(t *testing.T) {
var reply2 string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: nil,
AttributeIDs: &emptySlice,
@@ -329,7 +329,7 @@ func testV1FIdxSecondComputeThresholdsIndexes(t *testing.T) {
thid := []string{"TEST_PROFILE2"}
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &thid,
AttributeIDs: &emptySlice,
@@ -358,7 +358,7 @@ func testV1FIdxSecondComputeThresholdsIndexes(t *testing.T) {
func testV1FIdxThirdComputeThresholdsIndexes(t *testing.T) {
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: nil,
AttributeIDs: &emptySlice,
@@ -390,7 +390,7 @@ func testV1FIdxThirdComputeThresholdsIndexes(t *testing.T) {
func testV1FIdxRemoveThresholdProfile(t *testing.T) {
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: nil,
AttributeIDs: &emptySlice,
@@ -518,7 +518,7 @@ func testV1FIdxSetStatQueueProfileIndexes(t *testing.T) {
func testV1FIdxComputeStatQueueProfileIndexes(t *testing.T) {
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -628,7 +628,7 @@ func testV1FIdxSetSecondStatQueueProfileIndexes(t *testing.T) {
func testV1FIdxSecondComputeStatQueueProfileIndexes(t *testing.T) {
var result string
if err := tFIdxRpc.Call(
utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -658,7 +658,7 @@ func testV1FIdxSecondComputeStatQueueProfileIndexes(t *testing.T) {
func testV1FIdxRemoveStatQueueProfile(t *testing.T) {
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -775,7 +775,7 @@ func testV1FIdxSetResourceProfileIndexes(t *testing.T) {
func testV1FIdxComputeResourceProfileIndexes(t *testing.T) {
var reply2 string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -876,7 +876,7 @@ func testV1FIdxSecondComputeResourceProfileIndexes(t *testing.T) {
rsid := []string{"RCFG2"}
var reply2 string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -906,7 +906,7 @@ func testV1FIdxSecondComputeResourceProfileIndexes(t *testing.T) {
func testV1FIdxRemoveResourceProfile(t *testing.T) {
var resp string
var reply2 string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -1028,7 +1028,7 @@ func testV1FIdxSetSupplierProfileIndexes(t *testing.T) {
func testV1FIdxComputeSupplierProfileIndexes(t *testing.T) {
var reply2 string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -1133,7 +1133,7 @@ func testV1FIdxSecondComputeSupplierProfileIndexes(t *testing.T) {
spid := []string{"TEST_PROFILE2"}
var reply2 string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -1164,7 +1164,7 @@ func testV1FIdxSecondComputeSupplierProfileIndexes(t *testing.T) {
func testV1FIdxRemoveSupplierProfile(t *testing.T) {
var resp string
var reply2 string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexes{
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes, utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
ThresholdIDs: &emptySlice,
AttributeIDs: &emptySlice,
@@ -1296,7 +1296,7 @@ func testV1FIdxSetAttributeProfileIndexes(t *testing.T) {
func testV1FIdxComputeAttributeProfileIndexes(t *testing.T) {
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
Context: utils.MetaSessionS,
ThresholdIDs: &emptySlice,
@@ -1412,7 +1412,7 @@ func testV1FIdxSetSecondAttributeProfileIndexes(t *testing.T) {
func testV1FIdxSecondComputeAttributeProfileIndexes(t *testing.T) {
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
Context: utils.MetaSessionS,
ThresholdIDs: &emptySlice,
@@ -1445,7 +1445,7 @@ func testV1FIdxSecondComputeAttributeProfileIndexes(t *testing.T) {
func testV1FIdxComputeWithAnotherContext(t *testing.T) {
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
Context: utils.META_ANY,
ThresholdIDs: &emptySlice,
@@ -1480,7 +1480,7 @@ func testV1FIdxComputeWithAnotherContext(t *testing.T) {
func testV1FIdxRemoveAttributeProfile(t *testing.T) {
var result string
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
Context: utils.MetaSessionS,
ThresholdIDs: &emptySlice,
@@ -1824,7 +1824,7 @@ func testV1FIdxComputeDispatcherProfileIndexes(t *testing.T) {
var result string
//recompute indexes for dispatcherProfile for *sessions subsystem
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
Context: utils.MetaSessionS,
ThresholdIDs: &emptySlice,
@@ -1977,7 +1977,7 @@ func testV1FIdxComputeDispatcherProfileIndexes2(t *testing.T) {
var result string
//recompute indexes for dispatcherProfile for *sessions subsystem
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
Context: utils.MetaSessionS,
ThresholdIDs: &emptySlice,
@@ -2011,7 +2011,7 @@ func testV1FIdxComputeDispatcherProfileIndexes2(t *testing.T) {
//recompute indexes for dispatcherProfile for *attributes subsystem
if err := tFIdxRpc.Call(utils.ApierV1ComputeFilterIndexes,
utils.ArgsComputeFilterIndexes{
utils.ArgsComputeFilterIndexIDs{
Tenant: tenant,
Context: utils.MetaAttributes,
ThresholdIDs: &emptySlice,

129
apier/v1/triggers.go
View File

@@ -20,6 +20,7 @@ package v1
import (
"strings"
"time"
"github.com/cgrates/cgrates/config"
"github.com/cgrates/cgrates/engine"
@@ -28,11 +29,11 @@ import (
)
// Returns a list of ActionTriggers on an account
func (self *ApierV1) GetAccountActionTriggers(attrs utils.TenantAccount, reply *engine.ActionTriggers) error {
func (api *ApierV1) GetAccountActionTriggers(attrs utils.TenantAccount, reply *engine.ActionTriggers) error {
if missing := utils.MissingStructFields(&attrs, []string{"Tenant", "Account"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
if account, err := self.DataManager.GetAccount(utils.ConcatenatedKey(attrs.Tenant, attrs.Account)); err != nil {
if account, err := api.DataManager.GetAccount(utils.ConcatenatedKey(attrs.Tenant, attrs.Account)); err != nil {
return utils.NewErrServerError(err)
} else {
ats := account.ActionTriggers
@@ -47,64 +48,58 @@ func (self *ApierV1) GetAccountActionTriggers(attrs utils.TenantAccount, reply *
type AttrAddAccountActionTriggers struct {
Tenant string
Account string
ActionTriggerIDs *[]string
ActionTriggerIDs []string
ActionTriggerOverwrite bool
ActivationDate string
Executed bool
}
func (self *ApierV1) AddAccountActionTriggers(attr AttrAddAccountActionTriggers, reply *string) error {
func (api *ApierV1) AddAccountActionTriggers(attr AttrAddAccountActionTriggers, reply *string) (err error) {
if missing := utils.MissingStructFields(&attr, []string{"Tenant", "Account"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
actTime, err := utils.ParseTimeDetectLayout(attr.ActivationDate,
self.Config.GeneralCfg().DefaultTimezone)
if err != nil {
*reply = err.Error()
return err
var actTime time.Time
if actTime, err = utils.ParseTimeDetectLayout(attr.ActivationDate,
api.Config.GeneralCfg().DefaultTimezone); err != nil {
return
}
accID := utils.ConcatenatedKey(attr.Tenant, attr.Account)
var account *engine.Account
_, err = guardian.Guardian.Guard(func() (interface{}, error) {
if acc, err := self.DataManager.GetAccount(accID); err == nil {
account = acc
} else {
if account, err = api.DataManager.GetAccount(accID); err != nil {
return 0, err
}
if attr.ActionTriggerIDs != nil {
if attr.ActionTriggerOverwrite {
account.ActionTriggers = make(engine.ActionTriggers, 0)
if attr.ActionTriggerOverwrite {
account.ActionTriggers = make(engine.ActionTriggers, 0)
}
for _, actionTriggerID := range attr.ActionTriggerIDs {
atrs, err := api.DataManager.GetActionTriggers(actionTriggerID, false, utils.NonTransactional)
if err != nil {
return 0, err
}
for _, actionTriggerID := range *attr.ActionTriggerIDs {
atrs, err := self.DataManager.GetActionTriggers(actionTriggerID, false, utils.NonTransactional)
if err != nil {
return 0, err
for _, at := range atrs {
var found bool
for _, existingAt := range account.ActionTriggers {
if existingAt.Equals(at) {
found = true
break
}
}
for _, at := range atrs {
var found bool
for _, existingAt := range account.ActionTriggers {
if existingAt.Equals(at) {
found = true
break
}
}
at.ActivationDate = actTime
at.Executed = attr.Executed
if !found {
account.ActionTriggers = append(account.ActionTriggers, at)
}
at.ActivationDate = actTime
at.Executed = attr.Executed
if !found {
account.ActionTriggers = append(account.ActionTriggers, at)
}
}
}
account.InitCounters()
return 0, self.DataManager.SetAccount(account)
return 0, api.DataManager.SetAccount(account)
}, config.CgrConfig().GeneralCfg().LockingTimeout, utils.ACCOUNT_PREFIX+accID)
if err != nil {
*reply = err.Error()
return err
return
}
*reply = utils.OK
return nil
return
}
type AttrRemoveAccountActionTriggers struct {
@@ -114,14 +109,14 @@ type AttrRemoveAccountActionTriggers struct {
UniqueID string
}
func (self *ApierV1) RemoveAccountActionTriggers(attr AttrRemoveAccountActionTriggers, reply *string) error {
func (api *ApierV1) RemoveAccountActionTriggers(attr AttrRemoveAccountActionTriggers, reply *string) error {
if missing := utils.MissingStructFields(&attr, []string{"Tenant", "Account"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
accID := utils.ConcatenatedKey(attr.Tenant, attr.Account)
_, err := guardian.Guardian.Guard(func() (interface{}, error) {
var account *engine.Account
if acc, err := self.DataManager.GetAccount(accID); err == nil {
if acc, err := api.DataManager.GetAccount(accID); err == nil {
account = acc
} else {
return 0, err
@@ -137,7 +132,7 @@ func (self *ApierV1) RemoveAccountActionTriggers(attr AttrRemoveAccountActionTri
}
account.ActionTriggers = newActionTriggers
account.InitCounters()
return 0, self.DataManager.SetAccount(account)
return 0, api.DataManager.SetAccount(account)
}, config.CgrConfig().GeneralCfg().LockingTimeout, accID)
if err != nil {
*reply = err.Error()
@@ -155,7 +150,7 @@ type AttrResetAccountActionTriggers struct {
Executed bool
}
func (self *ApierV1) ResetAccountActionTriggers(attr AttrResetAccountActionTriggers, reply *string) error {
func (api *ApierV1) ResetAccountActionTriggers(attr AttrResetAccountActionTriggers, reply *string) error {
if missing := utils.MissingStructFields(&attr, []string{"Tenant", "Account"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
@@ -163,7 +158,7 @@ func (self *ApierV1) ResetAccountActionTriggers(attr AttrResetAccountActionTrigg
accID := utils.ConcatenatedKey(attr.Tenant, attr.Account)
var account *engine.Account
_, err := guardian.Guardian.Guard(func() (interface{}, error) {
if acc, err := self.DataManager.GetAccount(accID); err == nil {
if acc, err := api.DataManager.GetAccount(accID); err == nil {
account = acc
} else {
return 0, err
@@ -179,7 +174,7 @@ func (self *ApierV1) ResetAccountActionTriggers(attr AttrResetAccountActionTrigg
if attr.Executed == false {
account.ExecuteActionTriggers(nil)
}
return 0, self.DataManager.SetAccount(account)
return 0, api.DataManager.SetAccount(account)
}, config.CgrConfig().GeneralCfg().LockingTimeout, utils.ACCOUNT_PREFIX+accID)
if err != nil {
*reply = err.Error()
@@ -203,7 +198,6 @@ type AttrSetAccountActionTriggers struct {
ActivationDate *string
BalanceID *string
BalanceType *string
BalanceDirections *[]string
BalanceDestinationIds *[]string
BalanceWeight *float64
BalanceExpirationDate *string
@@ -217,7 +211,7 @@ type AttrSetAccountActionTriggers struct {
ActionsID *string
}
func (self *ApierV1) SetAccountActionTriggers(attr AttrSetAccountActionTriggers, reply *string) error {
func (api *ApierV1) SetAccountActionTriggers(attr AttrSetAccountActionTriggers, reply *string) error {
if missing := utils.MissingStructFields(&attr, []string{"Tenant", "Account"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
@@ -225,7 +219,7 @@ func (self *ApierV1) SetAccountActionTriggers(attr AttrSetAccountActionTriggers,
accID := utils.ConcatenatedKey(attr.Tenant, attr.Account)
var account *engine.Account
_, err := guardian.Guardian.Guard(func() (interface{}, error) {
if acc, err := self.DataManager.GetAccount(accID); err == nil {
if acc, err := api.DataManager.GetAccount(accID); err == nil {
account = acc
} else {
return 0, err
@@ -255,7 +249,7 @@ func (self *ApierV1) SetAccountActionTriggers(attr AttrSetAccountActionTriggers,
}
if attr.ExpirationDate != nil {
expTime, err := utils.ParseTimeDetectLayout(*attr.ExpirationDate,
self.Config.GeneralCfg().DefaultTimezone)
api.Config.GeneralCfg().DefaultTimezone)
if err != nil {
return 0, err
}
@@ -263,7 +257,7 @@ func (self *ApierV1) SetAccountActionTriggers(attr AttrSetAccountActionTriggers,
}
if attr.ActivationDate != nil {
actTime, err := utils.ParseTimeDetectLayout(*attr.ActivationDate,
self.Config.GeneralCfg().DefaultTimezone)
api.Config.GeneralCfg().DefaultTimezone)
if err != nil {
return 0, err
}
@@ -284,7 +278,7 @@ func (self *ApierV1) SetAccountActionTriggers(attr AttrSetAccountActionTriggers,
}
if attr.BalanceExpirationDate != nil {
balanceExpTime, err := utils.ParseTimeDetectLayout(*attr.BalanceExpirationDate,
self.Config.GeneralCfg().DefaultTimezone)
api.Config.GeneralCfg().DefaultTimezone)
if err != nil {
return 0, err
}
@@ -318,7 +312,7 @@ func (self *ApierV1) SetAccountActionTriggers(attr AttrSetAccountActionTriggers,
}
account.ExecuteActionTriggers(nil)
return 0, self.DataManager.SetAccount(account)
return 0, api.DataManager.SetAccount(account)
}, config.CgrConfig().GeneralCfg().LockingTimeout, utils.ACCOUNT_PREFIX+accID)
if err != nil {
*reply = err.Error()
@@ -333,12 +327,12 @@ type AttrRemoveActionTrigger struct {
UniqueID string
}
func (self *ApierV1) RemoveActionTrigger(attr AttrRemoveActionTrigger, reply *string) error {
func (api *ApierV1) RemoveActionTrigger(attr AttrRemoveActionTrigger, reply *string) error {
if missing := utils.MissingStructFields(&attr, []string{"GroupID"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
if attr.UniqueID == "" {
err := self.DataManager.RemoveActionTriggers(attr.GroupID, utils.NonTransactional)
err := api.DataManager.RemoveActionTriggers(attr.GroupID, utils.NonTransactional)
if err != nil {
*reply = err.Error()
} else {
@@ -346,7 +340,7 @@ func (self *ApierV1) RemoveActionTrigger(attr AttrRemoveActionTrigger, reply *st
}
return err
} else {
atrs, err := self.DataManager.GetActionTriggers(attr.GroupID, false, utils.NonTransactional)
atrs, err := api.DataManager.GetActionTriggers(attr.GroupID, false, utils.NonTransactional)
if err != nil {
*reply = err.Error()
return err
@@ -359,7 +353,7 @@ func (self *ApierV1) RemoveActionTrigger(attr AttrRemoveActionTrigger, reply *st
remainingAtrs = append(remainingAtrs, atr)
}
// set the cleared list back
err = self.DataManager.SetActionTriggers(attr.GroupID, remainingAtrs, utils.NonTransactional)
err = api.DataManager.SetActionTriggers(attr.GroupID, remainingAtrs, utils.NonTransactional)
if err != nil {
*reply = err.Error()
} else {
@@ -380,7 +374,6 @@ type AttrSetActionTrigger struct {
ActivationDate *string
BalanceID *string
BalanceType *string
BalanceDirections *[]string
BalanceDestinationIds *[]string
BalanceWeight *float64
BalanceExpirationDate *string
@@ -394,13 +387,13 @@ type AttrSetActionTrigger struct {
ActionsID *string
}
func (self *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string) (err error) {
func (api *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string) (err error) {
if missing := utils.MissingStructFields(&attr, []string{"GroupID"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
atrs, _ := self.DataManager.GetActionTriggers(attr.GroupID, false, utils.NonTransactional)
atrs, _ := api.DataManager.GetActionTriggers(attr.GroupID, false, utils.NonTransactional)
var newAtr *engine.ActionTrigger
if attr.UniqueID != "" {
//search for exiting one
@@ -442,7 +435,7 @@ func (self *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string)
}
if attr.ExpirationDate != nil {
expTime, err := utils.ParseTimeDetectLayout(*attr.ExpirationDate,
self.Config.GeneralCfg().DefaultTimezone)
api.Config.GeneralCfg().DefaultTimezone)
if err != nil {
*reply = err.Error()
return err
@@ -451,7 +444,7 @@ func (self *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string)
}
if attr.ActivationDate != nil {
actTime, err := utils.ParseTimeDetectLayout(*attr.ActivationDate,
self.Config.GeneralCfg().DefaultTimezone)
api.Config.GeneralCfg().DefaultTimezone)
if err != nil {
*reply = err.Error()
return err
@@ -473,7 +466,7 @@ func (self *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string)
}
if attr.BalanceExpirationDate != nil {
balanceExpTime, err := utils.ParseTimeDetectLayout(*attr.BalanceExpirationDate,
self.Config.GeneralCfg().DefaultTimezone)
api.Config.GeneralCfg().DefaultTimezone)
if err != nil {
*reply = err.Error()
return err
@@ -504,7 +497,7 @@ func (self *ApierV1) SetActionTrigger(attr AttrSetActionTrigger, reply *string)
if attr.ActionsID != nil {
newAtr.ActionsID = *attr.ActionsID
}
if err = self.DataManager.SetActionTriggers(attr.GroupID, atrs, utils.NonTransactional); err != nil {
if err = api.DataManager.SetActionTriggers(attr.GroupID, atrs, utils.NonTransactional); err != nil {
return
}
//no cache for action triggers
@@ -516,11 +509,11 @@ type AttrGetActionTriggers struct {
GroupIDs []string
}
func (self *ApierV1) GetActionTriggers(attr AttrGetActionTriggers, atrs *engine.ActionTriggers) error {
func (api *ApierV1) GetActionTriggers(attr AttrGetActionTriggers, atrs *engine.ActionTriggers) error {
var allAttrs engine.ActionTriggers
if len(attr.GroupIDs) > 0 {
for _, key := range attr.GroupIDs {
getAttrs, err := self.DataManager.GetActionTriggers(key, false, utils.NonTransactional)
getAttrs, err := api.DataManager.GetActionTriggers(key, false, utils.NonTransactional)
if err != nil {
return err
}
@@ -528,12 +521,12 @@ func (self *ApierV1) GetActionTriggers(attr AttrGetActionTriggers, atrs *engine.
}
} else {
keys, err := self.DataManager.DataDB().GetKeysForPrefix(utils.ACTION_TRIGGER_PREFIX)
keys, err := api.DataManager.DataDB().GetKeysForPrefix(utils.ACTION_TRIGGER_PREFIX)
if err != nil {
return err
}
for _, key := range keys {
getAttrs, err := self.DataManager.GetActionTriggers(key[len(utils.ACTION_TRIGGER_PREFIX):], false, utils.NonTransactional)
getAttrs, err := api.DataManager.GetActionTriggers(key[len(utils.ACTION_TRIGGER_PREFIX):], false, utils.NonTransactional)
if err != nil {
return err
}
@@ -563,7 +556,7 @@ type AttrAddActionTrigger struct {
}
// Deprecated in rc8, replaced by AddAccountActionTriggers
func (self *ApierV1) AddTriggeredAction(attr AttrAddActionTrigger, reply *string) error {
func (api *ApierV1) AddTriggeredAction(attr AttrAddActionTrigger, reply *string) error {
if missing := utils.MissingStructFields(&attr, []string{"Tenant", "Account"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
@@ -592,7 +585,7 @@ func (self *ApierV1) AddTriggeredAction(attr AttrAddActionTrigger, reply *string
at.Balance.Weight = utils.Float64Pointer(attr.BalanceWeight)
}
if balExpiryTime, err := utils.ParseTimeDetectLayout(attr.BalanceExpiryTime,
self.Config.GeneralCfg().DefaultTimezone); err != nil {
api.Config.GeneralCfg().DefaultTimezone); err != nil {
return utils.NewErrServerError(err)
} else {
at.Balance.ExpirationDate = &balExpiryTime
@@ -602,13 +595,13 @@ func (self *ApierV1) AddTriggeredAction(attr AttrAddActionTrigger, reply *string
}
acntID := utils.ConcatenatedKey(attr.Tenant, attr.Account)
_, err := guardian.Guardian.Guard(func() (interface{}, error) {
acnt, err := self.DataManager.GetAccount(acntID)
acnt, err := api.DataManager.GetAccount(acntID)
if err != nil {
return 0, err
}
acnt.ActionTriggers = append(acnt.ActionTriggers, at)
return 0, self.DataManager.SetAccount(acnt)
return 0, api.DataManager.SetAccount(acnt)
}, config.CgrConfig().GeneralCfg().LockingTimeout, utils.ACCOUNT_PREFIX+acntID)
if err != nil {
return err

196
apier/v2/accounts.go
View File

@@ -28,14 +28,14 @@ import (
"github.com/cgrates/cgrates/utils"
)
func (self *ApierV2) GetAccounts(attr utils.AttrGetAccounts, reply *[]*engine.Account) error {
func (apiv2 *ApierV2) GetAccounts(attr utils.AttrGetAccounts, reply *[]*engine.Account) error {
if len(attr.Tenant) == 0 {
return utils.NewErrMandatoryIeMissing("Tenant")
}
var accountKeys []string
var err error
if len(attr.AccountIds) == 0 {
if accountKeys, err = self.DataManager.DataDB().GetKeysForPrefix(utils.ACCOUNT_PREFIX + attr.Tenant); err != nil {
if accountKeys, err = apiv2.DataManager.DataDB().GetKeysForPrefix(utils.ACCOUNT_PREFIX + attr.Tenant); err != nil {
return err
}
} else {
@@ -64,7 +64,7 @@ func (self *ApierV2) GetAccounts(attr utils.AttrGetAccounts, reply *[]*engine.Ac
}
retAccounts := make([]*engine.Account, 0)
for _, acntKey := range limitedAccounts {
if acnt, err := self.DataManager.GetAccount(acntKey[len(utils.ACCOUNT_PREFIX):]); err != nil && err != utils.ErrNotFound { // Not found is not an error here
if acnt, err := apiv2.DataManager.GetAccount(acntKey[len(utils.ACCOUNT_PREFIX):]); err != nil && err != utils.ErrNotFound { // Not found is not an error here
return err
} else if acnt != nil {
if attr.Disabled != nil && *attr.Disabled != acnt.Disabled {
@@ -78,9 +78,9 @@ func (self *ApierV2) GetAccounts(attr utils.AttrGetAccounts, reply *[]*engine.Ac
}
// Get balance
func (self *ApierV2) GetAccount(attr *utils.AttrGetAccount, reply *engine.Account) error {
func (apiv2 *ApierV2) GetAccount(attr *utils.AttrGetAccount, reply *engine.Account) error {
tag := utils.ConcatenatedKey(attr.Tenant, attr.Account)
account, err := self.DataManager.GetAccount(tag)
account, err := apiv2.DataManager.GetAccount(tag)
if err != nil {
return err
}
@@ -91,16 +91,16 @@ func (self *ApierV2) GetAccount(attr *utils.AttrGetAccount, reply *engine.Accoun
type AttrSetAccount struct {
Tenant string
Account string
ActionPlanIDs *[]string
ActionPlanIDs []string
ActionPlansOverwrite bool
ActionTriggerIDs *[]string
ActionTriggerIDs []string
ActionTriggerOverwrite bool
AllowNegative *bool
Disabled *bool
ReloadScheduler bool
}
func (self *ApierV2) SetAccount(attr AttrSetAccount, reply *string) error {
func (apiv2 *ApierV2) SetAccount(attr AttrSetAccount, reply *string) error {
if missing := utils.MissingStructFields(&attr, []string{"Tenant", "Account"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
@@ -109,116 +109,112 @@ func (self *ApierV2) SetAccount(attr AttrSetAccount, reply *string) error {
var ub *engine.Account
var schedNeedsReload bool
_, err := guardian.Guardian.Guard(func() (interface{}, error) {
if bal, _ := self.DataManager.GetAccount(accID); bal != nil {
if bal, _ := apiv2.DataManager.GetAccount(accID); bal != nil {
ub = bal
} else { // Not found in db, create it here
ub = &engine.Account{
ID: accID,
}
}
if attr.ActionPlanIDs != nil {
_, err := guardian.Guardian.Guard(func() (interface{}, error) {
acntAPids, err := self.DataManager.GetAccountActionPlans(accID, false, utils.NonTransactional)
if err != nil && err != utils.ErrNotFound {
return 0, err
}
if attr.ActionPlansOverwrite {
// clean previous action plans
for i := 0; i < len(acntAPids); {
apID := acntAPids[i]
if utils.IsSliceMember(*attr.ActionPlanIDs, apID) {
i++ // increase index since we don't remove from slice
continue // not removing the ones where
}
ap, err := self.DataManager.GetActionPlan(apID, false, utils.NonTransactional)
if err != nil {
return 0, err
}
delete(ap.AccountIDs, accID)
dirtyActionPlans[apID] = ap
acntAPids = append(acntAPids[:i], acntAPids[i+1:]...) // remove the item from the list so we can overwrite the real list
_, err := guardian.Guardian.Guard(func() (interface{}, error) {
acntAPids, err := apiv2.DataManager.GetAccountActionPlans(accID, false, utils.NonTransactional)
if err != nil && err != utils.ErrNotFound {
return 0, err
}
if attr.ActionPlansOverwrite {
// clean previous action plans
for i := 0; i < len(acntAPids); {
apID := acntAPids[i]
if utils.IsSliceMember(attr.ActionPlanIDs, apID) {
i++ // increase index since we don't remove from slice
continue // not removing the ones where
}
}
for _, apID := range *attr.ActionPlanIDs {
ap, err := self.DataManager.GetActionPlan(apID, false, utils.NonTransactional)
ap, err := apiv2.DataManager.GetActionPlan(apID, false, utils.NonTransactional)
if err != nil {
return 0, err
}
// create tasks
var schedTasks int // keep count on the number of scheduled tasks so we can compare with actions needed
for _, at := range ap.ActionTimings {
if at.IsASAP() {
t := &engine.Task{
Uuid: utils.GenUUID(),
AccountID: accID,
ActionsID: at.ActionsID,
}
if err = self.DataManager.DataDB().PushTask(t); err != nil {
return 0, err
}
schedTasks++
}
}
if schedTasks != 0 && !schedNeedsReload {
schedNeedsReload = true
}
if schedTasks == len(ap.ActionTimings) || // scheduled all actions, no need to add account to AP
utils.IsSliceMember(acntAPids, apID) {
continue // No need to reschedule since already there
}
if ap.AccountIDs == nil {
ap.AccountIDs = make(utils.StringMap)
}
ap.AccountIDs[accID] = true
delete(ap.AccountIDs, accID)
dirtyActionPlans[apID] = ap
acntAPids = append(acntAPids, apID)
acntAPids = append(acntAPids[:i], acntAPids[i+1:]...) // remove the item from the list so we can overwrite the real list
}
if len(dirtyActionPlans) != 0 && !schedNeedsReload {
schedNeedsReload = true
}
apIDs := make([]string, len(dirtyActionPlans))
i := 0
for actionPlanID, ap := range dirtyActionPlans {
if err := self.DataManager.SetActionPlan(actionPlanID, ap, true, utils.NonTransactional); err != nil {
return 0, err
}
apIDs[i] = actionPlanID
i++
}
if err := self.DataManager.CacheDataFromDB(utils.ACTION_PLAN_PREFIX, apIDs, true); err != nil {
return 0, err
}
if err := self.DataManager.SetAccountActionPlans(accID, acntAPids, true); err != nil {
return 0, err
}
return 0, self.DataManager.CacheDataFromDB(utils.AccountActionPlansPrefix, []string{accID}, true)
}, config.CgrConfig().GeneralCfg().LockingTimeout, utils.ACTION_PLAN_PREFIX)
if err != nil {
return 0, err
}
}
if attr.ActionTriggerIDs != nil {
if attr.ActionTriggerOverwrite {
ub.ActionTriggers = make(engine.ActionTriggers, 0)
}
for _, actionTriggerID := range *attr.ActionTriggerIDs {
atrs, err := self.DataManager.GetActionTriggers(actionTriggerID, false, utils.NonTransactional)
for _, apID := range attr.ActionPlanIDs {
ap, err := apiv2.DataManager.GetActionPlan(apID, false, utils.NonTransactional)
if err != nil {
return 0, err
}
for _, at := range atrs {
var found bool
for _, existingAt := range ub.ActionTriggers {
if existingAt.Equals(at) {
found = true
break
// create tasks
var schedTasks int // keep count on the number of scheduled tasks so we can compare with actions needed
for _, at := range ap.ActionTimings {
if at.IsASAP() {
t := &engine.Task{
Uuid: utils.GenUUID(),
AccountID: accID,
ActionsID: at.ActionsID,
}
if err = apiv2.DataManager.DataDB().PushTask(t); err != nil {
return 0, err
}
schedTasks++
}
if !found {
ub.ActionTriggers = append(ub.ActionTriggers, at)
}
if schedTasks != 0 && !schedNeedsReload {
schedNeedsReload = true
}
if schedTasks == len(ap.ActionTimings) || // scheduled all actions, no need to add account to AP
utils.IsSliceMember(acntAPids, apID) {
continue // No need to reschedule since already there
}
if ap.AccountIDs == nil {
ap.AccountIDs = make(utils.StringMap)
}
ap.AccountIDs[accID] = true
dirtyActionPlans[apID] = ap
acntAPids = append(acntAPids, apID)
}
if len(dirtyActionPlans) != 0 && !schedNeedsReload {
schedNeedsReload = true
}
apIDs := make([]string, len(dirtyActionPlans))
i := 0
for actionPlanID, ap := range dirtyActionPlans {
if err := apiv2.DataManager.SetActionPlan(actionPlanID, ap, true, utils.NonTransactional); err != nil {
return 0, err
}
apIDs[i] = actionPlanID
i++
}
if err := apiv2.DataManager.CacheDataFromDB(utils.ACTION_PLAN_PREFIX, apIDs, true); err != nil {
return 0, err
}
if err := apiv2.DataManager.SetAccountActionPlans(accID, acntAPids, true); err != nil {
return 0, err
}
return 0, apiv2.DataManager.CacheDataFromDB(utils.AccountActionPlansPrefix, []string{accID}, true)
}, config.CgrConfig().GeneralCfg().LockingTimeout, utils.ACTION_PLAN_PREFIX)
if err != nil {
return 0, err
}
if attr.ActionTriggerOverwrite {
ub.ActionTriggers = make(engine.ActionTriggers, 0)
}
for _, actionTriggerID := range attr.ActionTriggerIDs {
atrs, err := apiv2.DataManager.GetActionTriggers(actionTriggerID, false, utils.NonTransactional)
if err != nil {
return 0, err
}
for _, at := range atrs {
var found bool
for _, existingAt := range ub.ActionTriggers {
if existingAt.Equals(at) {
found = true
break
}
}
if !found {
ub.ActionTriggers = append(ub.ActionTriggers, at)
}
}
}
@@ -230,13 +226,13 @@ func (self *ApierV2) SetAccount(attr AttrSetAccount, reply *string) error {
ub.Disabled = *attr.Disabled
}
// All prepared, save account
return 0, self.DataManager.SetAccount(ub)
return 0, apiv2.DataManager.SetAccount(ub)
}, config.CgrConfig().GeneralCfg().LockingTimeout, utils.ACCOUNT_PREFIX+accID)
if err != nil {
return utils.NewErrServerError(err)
}
if attr.ReloadScheduler && schedNeedsReload {
sched := self.SchedulerService.GetScheduler()
sched := apiv2.SchedulerService.GetScheduler()
if sched == nil {
return errors.New(utils.SchedulerNotRunningCaps)
}

75
apier/v2/apier.go
View File

@@ -39,9 +39,9 @@ type ApierV2 struct {
}
// Call implements rpcclient.RpcClientConnection interface for internal RPC
func (self *ApierV2) Call(serviceMethod string,
func (apiv2 *ApierV2) Call(serviceMethod string,
args interface{}, reply interface{}) error {
return utils.APIerRPCCall(self, serviceMethod, args, reply)
return utils.APIerRPCCall(apiv2, serviceMethod, args, reply)
}
type AttrLoadRatingProfile struct {
@@ -50,14 +50,14 @@ type AttrLoadRatingProfile struct {
}
// Process dependencies and load a specific rating profile from storDb into dataDb.
func (self *ApierV2) LoadRatingProfile(attrs AttrLoadRatingProfile, reply *string) error {
func (apiv2 *ApierV2) LoadRatingProfile(attrs AttrLoadRatingProfile, reply *string) error {
if len(attrs.TPid) == 0 {
return utils.NewErrMandatoryIeMissing("TPid")
}
tpRpf := &utils.TPRatingProfile{TPid: attrs.TPid}
dbReader, err := engine.NewTpReader(self.DataManager.DataDB(), self.StorDb,
attrs.TPid, self.Config.GeneralCfg().DefaultTimezone,
self.CacheS, self.SchedulerS)
dbReader, err := engine.NewTpReader(apiv2.DataManager.DataDB(), apiv2.StorDb,
attrs.TPid, apiv2.Config.GeneralCfg().DefaultTimezone,
apiv2.CacheS, apiv2.SchedulerS)
if err != nil {
return utils.NewErrServerError(err)
}
@@ -74,13 +74,13 @@ type AttrLoadAccountActions struct {
}
// Process dependencies and load a specific AccountActions profile from storDb into dataDb.
func (self *ApierV2) LoadAccountActions(attrs AttrLoadAccountActions, reply *string) error {
func (apiv2 *ApierV2) LoadAccountActions(attrs AttrLoadAccountActions, reply *string) error {
if len(attrs.TPid) == 0 {
return utils.NewErrMandatoryIeMissing("TPid")
}
dbReader, err := engine.NewTpReader(self.DataManager.DataDB(), self.StorDb,
attrs.TPid, self.Config.GeneralCfg().DefaultTimezone,
self.CacheS, self.SchedulerS)
dbReader, err := engine.NewTpReader(apiv2.DataManager.DataDB(), apiv2.StorDb,
attrs.TPid, apiv2.Config.GeneralCfg().DefaultTimezone,
apiv2.CacheS, apiv2.SchedulerS)
if err != nil {
return utils.NewErrServerError(err)
}
@@ -91,7 +91,7 @@ func (self *ApierV2) LoadAccountActions(attrs AttrLoadAccountActions, reply *str
}, config.CgrConfig().GeneralCfg().LockingTimeout, attrs.AccountActionsId); err != nil {
return utils.NewErrServerError(err)
}
sched := self.SchedulerService.GetScheduler()
sched := apiv2.SchedulerService.GetScheduler()
if sched != nil {
sched.Reload()
}
@@ -99,7 +99,7 @@ func (self *ApierV2) LoadAccountActions(attrs AttrLoadAccountActions, reply *str
return nil
}
func (self *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder, reply *utils.LoadInstance) error {
func (apiv2 *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder, reply *utils.LoadInstance) error {
if len(attrs.FolderPath) == 0 {
return fmt.Errorf("%s:%s", utils.ErrMandatoryIeMissing.Error(), "FolderPath")
}
@@ -111,9 +111,9 @@ func (self *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder,
} else if !fi.IsDir() {
return utils.ErrInvalidPath
}
loader, err := engine.NewTpReader(self.DataManager.DataDB(),
engine.NewFileCSVStorage(utils.CSV_SEP, attrs.FolderPath, attrs.Recursive), "", self.Config.GeneralCfg().DefaultTimezone,
self.CacheS, self.SchedulerS)
loader, err := engine.NewTpReader(apiv2.DataManager.DataDB(),
engine.NewFileCSVStorage(utils.CSV_SEP, attrs.FolderPath, attrs.Recursive), "", apiv2.Config.GeneralCfg().DefaultTimezone,
apiv2.CacheS, apiv2.SchedulerS)
if err != nil {
return utils.NewErrServerError(err)
}
@@ -144,7 +144,7 @@ func (self *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder,
if err := loader.ReloadCache(caching, true, attrs.ArgDispatcher); err != nil {
return utils.NewErrServerError(err)
}
if self.SchedulerS != nil {
if apiv2.SchedulerS != nil {
utils.Logger.Info("ApierV2.LoadTariffPlanFromFolder, reloading scheduler.")
if err := loader.ReloadScheduler(true); err != nil {
return utils.NewErrServerError(err)
@@ -152,7 +152,7 @@ func (self *ApierV2) LoadTariffPlanFromFolder(attrs utils.AttrLoadTpFromFolder,
}
// release the reader with it's structures
loader.Init()
loadHistList, err := self.DataManager.DataDB().GetLoadHistory(1, true, utils.NonTransactional)
loadHistList, err := apiv2.DataManager.DataDB().GetLoadHistory(1, true, utils.NonTransactional)
if err != nil {
return err
}
@@ -169,11 +169,11 @@ type AttrGetActions struct {
}
// Retrieves actions attached to specific ActionsId within cache
func (self *ApierV2) GetActions(attr AttrGetActions, reply *map[string]engine.Actions) error {
func (apiv2 *ApierV2) GetActions(attr AttrGetActions, reply *map[string]engine.Actions) error {
var actionKeys []string
var err error
if len(attr.ActionIDs) == 0 {
if actionKeys, err = self.DataManager.DataDB().GetKeysForPrefix(utils.ACTION_PREFIX); err != nil {
if actionKeys, err = apiv2.DataManager.DataDB().GetKeysForPrefix(utils.ACTION_PREFIX); err != nil {
return err
}
} else {
@@ -203,7 +203,7 @@ func (self *ApierV2) GetActions(attr AttrGetActions, reply *map[string]engine.Ac
retActions := make(map[string]engine.Actions)
for _, accKey := range limitedActions {
key := accKey[len(utils.ACTION_PREFIX):]
acts, err := self.DataManager.GetActions(key, false, utils.NonTransactional)
acts, err := apiv2.DataManager.GetActions(key, false, utils.NonTransactional)
if err != nil {
return utils.NewErrServerError(err)
}
@@ -221,34 +221,25 @@ type AttrGetDestinations struct {
DestinationIDs []string
}
func (self *ApierV2) GetDestinations(attr AttrGetDestinations, reply *[]*engine.Destination) error {
dests := make([]*engine.Destination, 0)
if attr.DestinationIDs == nil {
return utils.NewErrMandatoryIeMissing("DestIDs")
}
// GetDestinations returns a list of destination based on the destinationIDs given
func (apiv2 *ApierV2) GetDestinations(attr AttrGetDestinations, reply *[]*engine.Destination) (err error) {
if len(attr.DestinationIDs) == 0 {
// get all destination ids
destIDs, err := self.DataManager.DataDB().GetKeysForPrefix(utils.DESTINATION_PREFIX)
if err != nil {
return err
}
for _, destID := range destIDs {
attr.DestinationIDs = append(attr.DestinationIDs, destID[len(utils.DESTINATION_PREFIX):])
if attr.DestinationIDs, err = apiv2.DataManager.DataDB().GetKeysForPrefix(utils.DESTINATION_PREFIX); err != nil {
return
}
}
for _, destID := range attr.DestinationIDs {
dst, err := self.DataManager.GetDestination(destID, false, utils.NonTransactional)
if err != nil {
return err
dests := make([]*engine.Destination, len(attr.DestinationIDs))
for i, destID := range attr.DestinationIDs {
if dests[i], err = apiv2.DataManager.GetDestination(destID, false, utils.NonTransactional); err != nil {
return
}
dests = append(dests, dst)
}
*reply = dests
return nil
return
}
func (self *ApierV2) SetActions(attrs utils.AttrSetActions, reply *string) error {
func (apiv2 *ApierV2) SetActions(attrs utils.AttrSetActions, reply *string) error {
if missing := utils.MissingStructFields(&attrs, []string{"ActionsId", "Actions"}); len(missing) != 0 {
return utils.NewErrMandatoryIeMissing(missing...)
}
@@ -262,7 +253,7 @@ func (self *ApierV2) SetActions(attrs utils.AttrSetActions, reply *string) error
}
}
if !attrs.Overwrite {
if exists, err := self.DataManager.HasData(utils.ACTION_PREFIX, attrs.ActionsId, ""); err != nil {
if exists, err := apiv2.DataManager.HasData(utils.ACTION_PREFIX, attrs.ActionsId, ""); err != nil {
return utils.NewErrServerError(err)
} else if exists {
return utils.ErrExists
@@ -330,11 +321,11 @@ func (self *ApierV2) SetActions(attrs utils.AttrSetActions, reply *string) error
}
storeActions[idx] = a
}
if err := self.DataManager.SetActions(attrs.ActionsId, storeActions, utils.NonTransactional); err != nil {
if err := apiv2.DataManager.SetActions(attrs.ActionsId, storeActions, utils.NonTransactional); err != nil {
return utils.NewErrServerError(err)
}
//generate a loadID for CacheActions and store it in database
if err := self.DataManager.SetLoadIDs(map[string]int64{utils.CacheActions: time.Now().UnixNano()}); err != nil {
if err := apiv2.DataManager.SetLoadIDs(map[string]int64{utils.CacheActions: time.Now().UnixNano()}); err != nil {
return utils.APIErrorHandler(err)
}
*reply = utils.OK

33
apier/v2/cdre.go
View File

@@ -41,23 +41,14 @@ type AttrExportCdrsToFile struct {
utils.RPCCDRsFilter // Inherit the CDR filter attributes
}
type ExportedFileCdrs struct {
ExportedFilePath string // Full path to the newly generated export file
TotalRecords int // Number of CDRs to be exported
TotalCost float64 // Sum of all costs in exported CDRs
FirstOrderId, LastOrderId int64 // The order id of the last exported CDR
ExportedCgrIds []string // List of successfuly exported cgrids in the file
UnexportedCgrIds map[string]string // Map of errored CDRs, map key is cgrid, value will be the error string
}
// Deprecated, please use ApierV1.ExportCDRs instead
func (self *ApierV2) ExportCdrsToFile(attr AttrExportCdrsToFile, reply *ExportedFileCdrs) (err error) {
cdreReloadStruct := <-self.Config.ConfigReloads[utils.CDRE] // Read the content of the channel, locking it
defer func() { self.Config.ConfigReloads[utils.CDRE] <- cdreReloadStruct }() // Unlock reloads at exit
exportTemplate := self.Config.CdreProfiles[utils.META_DEFAULT]
func (apiv2 *ApierV2) ExportCdrsToFile(attr AttrExportCdrsToFile, reply *utils.ExportedFileCdrs) (err error) {
cdreReloadStruct := <-apiv2.Config.ConfigReloads[utils.CDRE] // Read the content of the channel, locking it
defer func() { apiv2.Config.ConfigReloads[utils.CDRE] <- cdreReloadStruct }() // Unlock reloads at exit
exportTemplate := apiv2.Config.CdreProfiles[utils.META_DEFAULT]
if attr.ExportTemplate != nil && len(*attr.ExportTemplate) != 0 { // Export template prefered, use it
var hasIt bool
if exportTemplate, hasIt = self.Config.CdreProfiles[*attr.ExportTemplate]; !hasIt {
if exportTemplate, hasIt = apiv2.Config.CdreProfiles[*attr.ExportTemplate]; !hasIt {
return fmt.Errorf("%s:ExportTemplate", utils.ErrNotFound)
}
}
@@ -100,21 +91,21 @@ func (self *ApierV2) ExportCdrsToFile(attr AttrExportCdrsToFile, reply *Exported
if exportFormat == utils.DRYRUN {
filePath = utils.DRYRUN
}
cdrsFltr, err := attr.RPCCDRsFilter.AsCDRsFilter(self.Config.GeneralCfg().DefaultTimezone)
cdrsFltr, err := attr.RPCCDRsFilter.AsCDRsFilter(apiv2.Config.GeneralCfg().DefaultTimezone)
if err != nil {
return utils.NewErrServerError(err)
}
cdrs, _, err := self.CdrDb.GetCDRs(cdrsFltr, false)
cdrs, _, err := apiv2.CdrDb.GetCDRs(cdrsFltr, false)
if err != nil {
return err
} else if len(cdrs) == 0 {
*reply = ExportedFileCdrs{ExportedFilePath: ""}
*reply = utils.ExportedFileCdrs{ExportedFilePath: ""}
return nil
}
cdrexp, err := engine.NewCDRExporter(cdrs, exportTemplate, exportFormat,
filePath, utils.META_NONE, exportID, exportTemplate.Synchronous,
exportTemplate.Attempts, fieldSep, self.Config.GeneralCfg().HttpSkipTlsVerify,
self.HTTPPoster, self.AttributeS, self.FilterS)
exportTemplate.Attempts, fieldSep, apiv2.Config.GeneralCfg().HttpSkipTlsVerify,
apiv2.HTTPPoster, apiv2.AttributeS, apiv2.FilterS)
if err != nil {
return utils.NewErrServerError(err)
}
@@ -122,10 +113,10 @@ func (self *ApierV2) ExportCdrsToFile(attr AttrExportCdrsToFile, reply *Exported
return utils.NewErrServerError(err)
}
if cdrexp.TotalExportedCdrs() == 0 {
*reply = ExportedFileCdrs{ExportedFilePath: ""}
*reply = utils.ExportedFileCdrs{ExportedFilePath: ""}
return nil
}
*reply = ExportedFileCdrs{ExportedFilePath: filePath, TotalRecords: len(cdrs),
*reply = utils.ExportedFileCdrs{ExportedFilePath: filePath, TotalRecords: len(cdrs),
TotalCost: cdrexp.TotalCost(), FirstOrderId: cdrexp.FirstOrderId(), LastOrderId: cdrexp.LastOrderId()}
if !attr.Verbose {
reply.ExportedCgrIds = cdrexp.PositiveExports()

1
apier/v2/triggers.go
View File

@@ -41,7 +41,6 @@ type AttrSetAccountActionTriggers struct {
ActivationDate *string
BalanceID *string
BalanceType *string
BalanceDirections *[]string
BalanceDestinationIds *[]string
BalanceWeight *float64
BalanceExpirationDate *string

4
console/compute_filter_indexes.go
View File

@@ -34,7 +34,7 @@ func init() {
type CmdComputeFilterIndexes struct {
name string
rpcMethod string
rpcParams *utils.ArgsComputeFilterIndexes
rpcParams *utils.ArgsComputeFilterIndexIDs
*CommandExecuter
}
@@ -48,7 +48,7 @@ func (self *CmdComputeFilterIndexes) RpcMethod() string {
func (self *CmdComputeFilterIndexes) RpcParams(reset bool) interface{} {
if reset || self.rpcParams == nil {
self.rpcParams = &utils.ArgsComputeFilterIndexes{}
self.rpcParams = &utils.ArgsComputeFilterIndexIDs{}
}
return self.rpcParams
}

28
utils/apitpdata.go
View File

@@ -969,16 +969,28 @@ type ArgRSv1ResourceUsage struct {
*ArgDispatcher
}
type ArgsComputeFilterIndexes struct {
type ArgsComputeFilterIndexIDs struct {
Tenant string
Context string
AttributeIDs *[]string
ResourceIDs *[]string
StatIDs *[]string
SupplierIDs *[]string
ThresholdIDs *[]string
ChargerIDs *[]string
DispatcherIDs *[]string
AttributeIDs []string
ResourceIDs []string
StatIDs []string
SupplierIDs []string
ThresholdIDs []string
ChargerIDs []string
DispatcherIDs []string
}
type ArgsComputeFilterIndexes struct {
Tenant string
Context string
AttributeS bool
ResourceS bool
StatS bool
SupplierS bool
ThresholdS bool
ChargerS bool
DispatcherS bool
}
// AsActivationTime converts TPActivationInterval into ActivationInterval