Added RemoveFromDatabase and more remove methods and tests

2026-02-11 18:16:24 +05:00 · 2017-12-11 19:18:01 +02:00
parent ab8c504ea8
commit 8ef2a81d50
9 changed files with 1037 additions and 91 deletions
--- a/cmd/cgr-loader/cgr-loader.go
+++ b/cmd/cgr-loader/cgr-loader.go
@@ -67,6 +67,7 @@ var (
 	loadHistorySize = flag.Int("load_history_size", config.CgrConfig().LoadHistorySize, "Limit the number of records in the load history")
 	timezone        = flag.String("timezone", config.CgrConfig().DefaultTimezone, `Timezone for timestamps where not specified <""|UTC|Local|$IANA_TZ_DB>`)
 	disable_reverse = flag.Bool("disable_reverse_mappings", false, "Will disable reverse mappings rebuilding")
+	remove          = flag.Bool("remove", false, "Will remove any data from db that matches data files")
 )

 func main() {
@@ -217,107 +218,112 @@ func main() {
 	} else {
 		log.Print("WARNING: Users automatic data reload is disabled!")
 	}
-
-	// write maps to database
-	if err := tpReader.WriteToDatabase(*flush, *verbose, *disable_reverse); err != nil {
-		log.Fatal("Could not write to database: ", err)
-	}
-	if len(*historyServer) != 0 && *verbose {
-		log.Print("Wrote history.")
-	}
-	var dstIds, revDstIDs, rplIds, rpfIds, actIds, aapIDs, shgIds, alsIds, lcrIds, dcsIds, rspIDs, resIDs, aatIDs, ralsIDs []string
-	if rater != nil {
-		dstIds, _ = tpReader.GetLoadedIds(utils.DESTINATION_PREFIX)
-		revDstIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_DESTINATION_PREFIX)
-		rplIds, _ = tpReader.GetLoadedIds(utils.RATING_PLAN_PREFIX)
-		rpfIds, _ = tpReader.GetLoadedIds(utils.RATING_PROFILE_PREFIX)
-		actIds, _ = tpReader.GetLoadedIds(utils.ACTION_PREFIX)
-		aapIDs, _ = tpReader.GetLoadedIds(utils.AccountActionPlansPrefix)
-		shgIds, _ = tpReader.GetLoadedIds(utils.SHARED_GROUP_PREFIX)
-		alsIds, _ = tpReader.GetLoadedIds(utils.ALIASES_PREFIX)
-		lcrIds, _ = tpReader.GetLoadedIds(utils.LCR_PREFIX)
-		dcsIds, _ = tpReader.GetLoadedIds(utils.DERIVEDCHARGERS_PREFIX)
-		rspIDs, _ = tpReader.GetLoadedIds(utils.ResourceProfilesPrefix)
-		resIDs, _ = tpReader.GetLoadedIds(utils.ResourcesPrefix)
-		aatIDs, _ = tpReader.GetLoadedIds(utils.ACTION_TRIGGER_PREFIX)
-		ralsIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_ALIASES_PREFIX)
-	}
-	aps, _ := tpReader.GetLoadedIds(utils.ACTION_PLAN_PREFIX)
-	var statsQueueIds []string
-	if cdrstats != nil {
-		statsQueueIds, _ = tpReader.GetLoadedIds(utils.CDR_STATS_PREFIX)
-	}
-	var userIds []string
-	if users != nil {
-		userIds, _ = tpReader.GetLoadedIds(utils.USERS_PREFIX)
-	}
-	// release the reader with it's structures
-	tpReader.Init()
-
-	// Reload scheduler and cache
-	if rater != nil {
-		reply := ""
-
-		// Reload cache first since actions could be calling info from within
-		if *verbose {
-			log.Print("Reloading cache")
+	if !*remove {
+		// write maps to database
+		if err := tpReader.WriteToDatabase(*flush, *verbose, *disable_reverse); err != nil {
+			log.Fatal("Could not write to database: ", err)
 		}
-		if err = rater.Call("ApierV1.ReloadCache", utils.AttrReloadCache{ArgsCache: utils.ArgsCache{
-			DestinationIDs:        &dstIds,
-			ReverseDestinationIDs: &revDstIDs,
-			RatingPlanIDs:         &rplIds,
-			RatingProfileIDs:      &rpfIds,
-			ActionIDs:             &actIds,
-			ActionPlanIDs:         &aps,
-			AccountActionPlanIDs:  &aapIDs,
-			ActionTriggerIDs:      &aatIDs,
-			SharedGroupIDs:        &shgIds,
-			LCRids:                &lcrIds,
-			DerivedChargerIDs:     &dcsIds,
-			AliasIDs:              &alsIds,
-			ReverseAliasIDs:       &ralsIDs,
-			ResourceProfileIDs:    &rspIDs,
-			ResourceIDs:           &resIDs},
-			FlushAll: *flush,
-		}, &reply); err != nil {
-			log.Printf("WARNING: Got error on cache reload: %s\n", err.Error())
+		if len(*historyServer) != 0 && *verbose {
+			log.Print("Wrote history.")
 		}
+		var dstIds, revDstIDs, rplIds, rpfIds, actIds, aapIDs, shgIds, alsIds, lcrIds, dcsIds, rspIDs, resIDs, aatIDs, ralsIDs []string
+		if rater != nil {
+			dstIds, _ = tpReader.GetLoadedIds(utils.DESTINATION_PREFIX)
+			revDstIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_DESTINATION_PREFIX)
+			rplIds, _ = tpReader.GetLoadedIds(utils.RATING_PLAN_PREFIX)
+			rpfIds, _ = tpReader.GetLoadedIds(utils.RATING_PROFILE_PREFIX)
+			actIds, _ = tpReader.GetLoadedIds(utils.ACTION_PREFIX)
+			aapIDs, _ = tpReader.GetLoadedIds(utils.AccountActionPlansPrefix)
+			shgIds, _ = tpReader.GetLoadedIds(utils.SHARED_GROUP_PREFIX)
+			alsIds, _ = tpReader.GetLoadedIds(utils.ALIASES_PREFIX)
+			lcrIds, _ = tpReader.GetLoadedIds(utils.LCR_PREFIX)
+			dcsIds, _ = tpReader.GetLoadedIds(utils.DERIVEDCHARGERS_PREFIX)
+			rspIDs, _ = tpReader.GetLoadedIds(utils.ResourceProfilesPrefix)
+			resIDs, _ = tpReader.GetLoadedIds(utils.ResourcesPrefix)
+			aatIDs, _ = tpReader.GetLoadedIds(utils.ACTION_TRIGGER_PREFIX)
+			ralsIDs, _ = tpReader.GetLoadedIds(utils.REVERSE_ALIASES_PREFIX)
+		}
+		aps, _ := tpReader.GetLoadedIds(utils.ACTION_PLAN_PREFIX)
+		var statsQueueIds []string
+		if cdrstats != nil {
+			statsQueueIds, _ = tpReader.GetLoadedIds(utils.CDR_STATS_PREFIX)
+		}
+		var userIds []string
+		if users != nil {
+			userIds, _ = tpReader.GetLoadedIds(utils.USERS_PREFIX)
+		}
+		// release the reader with it's structures
+		tpReader.Init()

-		if len(aps) != 0 {
+		// Reload scheduler and cache
+		if rater != nil {
+			reply := ""
+
+			// Reload cache first since actions could be calling info from within
 			if *verbose {
-				log.Print("Reloading scheduler")
+				log.Print("Reloading cache")
 			}
-			if err = rater.Call("ApierV1.ReloadScheduler", "", &reply); err != nil {
-				log.Printf("WARNING: Got error on scheduler reload: %s\n", err.Error())
+			if err = rater.Call("ApierV1.ReloadCache", utils.AttrReloadCache{ArgsCache: utils.ArgsCache{
+				DestinationIDs:        &dstIds,
+				ReverseDestinationIDs: &revDstIDs,
+				RatingPlanIDs:         &rplIds,
+				RatingProfileIDs:      &rpfIds,
+				ActionIDs:             &actIds,
+				ActionPlanIDs:         &aps,
+				AccountActionPlanIDs:  &aapIDs,
+				ActionTriggerIDs:      &aatIDs,
+				SharedGroupIDs:        &shgIds,
+				LCRids:                &lcrIds,
+				DerivedChargerIDs:     &dcsIds,
+				AliasIDs:              &alsIds,
+				ReverseAliasIDs:       &ralsIDs,
+				ResourceProfileIDs:    &rspIDs,
+				ResourceIDs:           &resIDs},
+				FlushAll: *flush,
+			}, &reply); err != nil {
+				log.Printf("WARNING: Got error on cache reload: %s\n", err.Error())
+			}
+
+			if len(aps) != 0 {
+				if *verbose {
+					log.Print("Reloading scheduler")
+				}
+				if err = rater.Call("ApierV1.ReloadScheduler", "", &reply); err != nil {
+					log.Printf("WARNING: Got error on scheduler reload: %s\n", err.Error())
+				}
+			}
+
+		}
+		if cdrstats != nil {
+			if *flush {
+				statsQueueIds = []string{} // Force reload all
+			}
+			if len(statsQueueIds) != 0 {
+				if *verbose {
+					log.Print("Reloading CDRStats data")
+				}
+				var reply string
+				if err := cdrstats.Call("CDRStatsV1.ReloadQueues", utils.AttrCDRStatsReloadQueues{StatsQueueIds: statsQueueIds}, &reply); err != nil {
+					log.Printf("WARNING: Failed reloading stat queues, error: %s\n", err.Error())
+				}
 			}
 		}

-	}
-	if cdrstats != nil {
-		if *flush {
-			statsQueueIds = []string{} // Force reload all
-		}
-		if len(statsQueueIds) != 0 {
-			if *verbose {
-				log.Print("Reloading CDRStats data")
-			}
-			var reply string
-			if err := cdrstats.Call("CDRStatsV1.ReloadQueues", utils.AttrCDRStatsReloadQueues{StatsQueueIds: statsQueueIds}, &reply); err != nil {
-				log.Printf("WARNING: Failed reloading stat queues, error: %s\n", err.Error())
+		if users != nil {
+			if len(userIds) > 0 {
+				if *verbose {
+					log.Print("Reloading Users data")
+				}
+				var reply string
+				if err := cdrstats.Call("UsersV1.ReloadUsers", "", &reply); err != nil {
+					log.Printf("WARNING: Failed reloading users data, error: %s\n", err.Error())
+				}
+
 			}
 		}
-	}
-
-	if users != nil {
-		if len(userIds) > 0 {
-			if *verbose {
-				log.Print("Reloading Users data")
-			}
-			var reply string
-			if err := cdrstats.Call("UsersV1.ReloadUsers", "", &reply); err != nil {
-				log.Printf("WARNING: Failed reloading users data, error: %s\n", err.Error())
-			}
-
+	} else {
+		if err := tpReader.RemoveFromDatabase(*verbose, *disable_reverse); err != nil {
+			log.Fatal("Could not delete from database: ", err)
 		}
 	}
 }
--- a/engine/datamanager.go
+++ b/engine/datamanager.go
@@ -620,6 +620,19 @@ func (dm *DataManager) SetSharedGroup(sg *SharedGroup, transactionID string) (er
 	}
 }

+func (dm *DataManager) RemoveSharedGroup(id, transactionID string) (err error) {
+	if dm.DataDB().GetStorageType() == utils.MAPSTOR {
+		if err = dm.DataDB().RemoveSharedGroupDrv(id, transactionID); err != nil {
+			return
+		}
+		cache.RemKey(utils.SHARED_GROUP_PREFIX+id, cacheCommit(transactionID), transactionID)
+		return
+	} else {
+		return dm.DataDB().RemoveSharedGroupDrv(id, transactionID)
+	}
+
+}
+
 func (dm *DataManager) SetLCR(lcr *LCR, transactionID string) (err error) {
 	if dm.DataDB().GetStorageType() == utils.MAPSTOR {
 		if err = dm.DataDB().SetLCRDrv(lcr); err != nil {
@@ -631,6 +644,18 @@ func (dm *DataManager) SetLCR(lcr *LCR, transactionID string) (err error) {
 	}
 }

+func (dm *DataManager) RemoveLCR(id, transactionID string) (err error) {
+	if dm.DataDB().GetStorageType() == utils.MAPSTOR {
+		if err = dm.DataDB().RemoveLCRDrv(id, transactionID); err != nil {
+			return
+		}
+		cache.RemKey(utils.LCR_PREFIX+id, cacheCommit(transactionID), transactionID)
+		return
+	} else {
+		return dm.DataDB().RemoveLCRDrv(id, transactionID)
+	}
+}
+
 func (dm *DataManager) GetDerivedChargers(key string, skipCache bool, transactionID string) (dcs *utils.DerivedChargers, err error) {
 	cacheKey := utils.DERIVEDCHARGERS_PREFIX + key
 	if !skipCache {
@@ -652,6 +677,14 @@ func (dm *DataManager) GetDerivedChargers(key string, skipCache bool, transactio
 	return
 }

+func (dm *DataManager) RemoveDerivedChargers(id, transactionID string) (err error) {
+	if err = dm.DataDB().RemoveDerivedChargersDrv(id, transactionID); err != nil {
+		return
+	}
+	cache.RemKey(utils.DERIVEDCHARGERS_PREFIX+id, cacheCommit(transactionID), transactionID)
+	return
+}
+
 func (dm *DataManager) GetActions(key string, skipCache bool, transactionID string) (as Actions, err error) {
 	cachekey := utils.ACTION_PREFIX + key
 	if !skipCache {
@@ -728,6 +761,14 @@ func (dm *DataManager) SetRatingPlan(rp *RatingPlan, transactionID string) (err
 	}
 }

+func (dm *DataManager) RemoveRatingPlan(key string, transactionID string) (err error) {
+	if err = dm.DataDB().RemoveRatingPlanDrv(key); err != nil {
+		return
+	}
+	cache.RemKey(utils.RATING_PLAN_PREFIX+key, cacheCommit(transactionID), transactionID)
+	return
+}
+
 func (dm *DataManager) GetRatingProfile(key string, skipCache bool, transactionID string) (rpf *RatingProfile, err error) {
 	cachekey := utils.RATING_PROFILE_PREFIX + key
 	if !skipCache {
@@ -809,6 +850,10 @@ func (dm *DataManager) SetReqFilterIndexes(dbKey string, indexes map[string]map[
 	return dm.DataDB().SetReqFilterIndexesDrv(dbKey, indexes)
 }

+func (dm *DataManager) RemoveReqFilterIndexes(dbKey string) (err error) {
+	return dm.DataDB().RemoveReqFilterIndexesDrv(dbKey)
+}
+
 func (dm *DataManager) MatchReqFilterIndex(dbKey, fieldName, fieldVal string) (itemIDs utils.StringMap, err error) {
 	fieldValKey := utils.ConcatenatedKey(fieldName, fieldVal)
 	cacheKey := dbKey + fieldValKey
@@ -837,6 +882,10 @@ func (dm *DataManager) SetCdrStatsQueue(sq *CDRStatsQueue) (err error) {
 	return dm.DataDB().SetCdrStatsQueueDrv(sq)
 }

+func (dm *DataManager) RemoveCdrStatsQueue(key string) error {
+	return dm.DataDB().RemoveCdrStatsQueueDrv(key)
+}
+
 func (dm *DataManager) SetCdrStats(cs *CdrStats) error {
 	return dm.DataDB().SetCdrStatsDrv(cs)
 }
--- a/engine/loader_it_test.go
+++ b/engine/loader_it_test.go
@@ -79,6 +79,107 @@ func TestLoaderITCreateStorTpTables(t *testing.T) {
 	}
 }

+// Loads data from csv files in tp scenario to dataDbCsv
+func TestLoaderITRemoveLoad(t *testing.T) {
+	/*var err error
+	for fn, v := range FileValidators {
+		if err = ValidateCSVData(path.Join(*dataDir, "tariffplans", *tpCsvScenario, fn), v.Rule); err != nil {
+			t.Error("Failed validating data: ", err.Error())
+		}
+	}*/
+	loader = NewTpReader(dataDbCsv.DataDB(), NewFileCSVStorage(utils.CSV_SEP,
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.DESTINATIONS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.TIMINGS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.RATES_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.DESTINATION_RATES_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.RATING_PLANS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.RATING_PROFILES_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.SHARED_GROUPS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.LCRS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ACTIONS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ACTION_PLANS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ACTION_TRIGGERS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ACCOUNT_ACTIONS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.DERIVED_CHARGERS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.CDR_STATS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.USERS_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ALIASES_CSV),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ResourcesCsv),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.StatsCsv),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.ThresholdsCsv),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.FiltersCsv),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.SuppliersCsv),
+		path.Join(*dataDir, "tariffplans", *tpCsvScenario, utils.AttributesCsv),
+	), "", "")
+
+	if err = loader.LoadDestinations(); err != nil {
+		t.Error("Failed loading destinations: ", err.Error())
+	}
+	if err = loader.LoadTimings(); err != nil {
+		t.Error("Failed loading timings: ", err.Error())
+	}
+	if err = loader.LoadRates(); err != nil {
+		t.Error("Failed loading rates: ", err.Error())
+	}
+	if err = loader.LoadDestinationRates(); err != nil {
+		t.Error("Failed loading destination rates: ", err.Error())
+	}
+	if err = loader.LoadRatingPlans(); err != nil {
+		t.Error("Failed loading rating plans: ", err.Error())
+	}
+	if err = loader.LoadRatingProfiles(); err != nil {
+		t.Error("Failed loading rating profiles: ", err.Error())
+	}
+	if err = loader.LoadActions(); err != nil {
+		t.Error("Failed loading actions: ", err.Error())
+	}
+	if err = loader.LoadActionPlans(); err != nil {
+		t.Error("Failed loading action timings: ", err.Error())
+	}
+	if err = loader.LoadActionTriggers(); err != nil {
+		t.Error("Failed loading action triggers: ", err.Error())
+	}
+	if err = loader.LoadAccountActions(); err != nil {
+		t.Error("Failed loading account actions: ", err.Error())
+	}
+	if err = loader.LoadDerivedChargers(); err != nil {
+		t.Error("Failed loading derived chargers: ", err.Error())
+	}
+	if err = loader.LoadLCRs(); err != nil {
+		t.Error("Failed loading lcr rules: ", err.Error())
+	}
+	if err = loader.LoadUsers(); err != nil {
+		t.Error("Failed loading users: ", err.Error())
+	}
+	if err = loader.LoadAliases(); err != nil {
+		t.Error("Failed loading aliases: ", err.Error())
+	}
+	if err = loader.LoadFilters(); err != nil {
+		t.Error("Failed loading filters: ", err.Error())
+	}
+	if err = loader.LoadResourceProfiles(); err != nil {
+		t.Error("Failed loading resource profiles: ", err.Error())
+	}
+	if err = loader.LoadStats(); err != nil {
+		t.Error("Failed loading stats: ", err.Error())
+	}
+	if err = loader.LoadThresholds(); err != nil {
+		t.Error("Failed loading thresholds: ", err.Error())
+	}
+	if err = loader.LoadSupplierProfiles(); err != nil {
+		t.Error("Failed loading Supplier profiles: ", err.Error())
+	}
+	if err = loader.LoadAttributeProfiles(); err != nil {
+		t.Error("Failed loading Alias profiles: ", err.Error())
+	}
+	if err := loader.WriteToDatabase(true, false, false); err != nil {
+		t.Error("Could not write data into dataDb: ", err.Error())
+	}
+	if err := loader.RemoveFromDatabase(false, true); err != nil {
+		t.Error("Could not write data into dataDb: ", err.Error())
+	}
+}
+
 // Loads data from csv files in tp scenario to dataDbCsv
 func TestLoaderITLoadFromCSV(t *testing.T) {
 	/*var err error
--- a/engine/onstor_it_test.go
+++ b/engine/onstor_it_test.go
@@ -191,6 +191,12 @@ func testOnStorITSetGetDerivedCharges(t *testing.T) {
 	} else if !reflect.DeepEqual(rcvCharger, charger1) {
 		t.Errorf("Expecting %v, received: %v", charger1, rcvCharger)
 	}
+	if err := onStor.RemoveDerivedChargers(keyCharger1, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	if _, rcvErr := onStor.GetDerivedChargers(keyCharger1, false, utils.NonTransactional); rcvErr != utils.ErrNotFound {
+		t.Error(rcvErr)
+	}
 }

 func testOnStorITSetReqFilterIndexes(t *testing.T) {
@@ -258,6 +264,19 @@ func testOnStorITGetReqFilterIndexes(t *testing.T) {
 	if _, err := onStor.GetReqFilterIndexes("unknown_key"); err == nil || err != utils.ErrNotFound {
 		t.Error(err)
 	}
+	if err := onStor.RemoveReqFilterIndexes(utils.ResourceProfilesStringIndex); err != nil {
+		t.Error(err)
+	}
+	_, err := onStor.GetReqFilterIndexes(utils.ResourceProfilesStringIndex)
+	if err != utils.ErrNotFound {
+		//if err!=nil{
+		t.Error(err)
+		//}else if !reflect.DeepEqual(eIdxes, idxes) {
+		//	t.Errorf("Expecting: %+v, received: %+v", eIdxes, idxes)
+	}
+	if err := onStor.SetReqFilterIndexes(utils.ResourceProfilesStringIndex, eIdxes); err != nil {
+		t.Error(err)
+	}
 }

 func testOnStorITMatchReqFilterIndex(t *testing.T) {
@@ -533,6 +552,12 @@ func testOnStorITCacheActionPlan(t *testing.T) {
 	} else if rcv := itm.(*ActionPlan); !reflect.DeepEqual(ap, rcv) {
 		t.Errorf("Expecting: %+v, received: %+v", ap, rcv)
 	}
+	if err := onStor.DataDB().RemoveActionPlan(ap.Id, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	if err := onStor.DataDB().SetActionPlan(ap.Id, ap, true, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
 }

 func testOnStorITCacheAccountActionPlans(t *testing.T) {
@@ -1345,6 +1370,13 @@ func testOnStorITCRUDRatingPlan(t *testing.T) {
 	// if err = onStor.DataDB().SelectDatabase(onStorCfg); err != nil {
 	// 	t.Error(err)
 	// }
+	if err = onStor.RemoveRatingPlan(rp.Id, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	if _, rcvErr := onStor.GetRatingPlan(rp.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound {
+		t.Error(rcvErr)
+	}
+
 }

 func testOnStorITCRUDRatingProfile(t *testing.T) {
@@ -1534,6 +1566,12 @@ func testOnStorITCRUDLCR(t *testing.T) {
 	// if err = onStor.DataDB().SelectDatabase(onStorCfg); err != nil {
 	// 	t.Error(err)
 	// }
+	if err := onStor.RemoveLCR(lcr.GetId(), utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	if _, rcvErr := onStor.GetLCR(lcr.GetId(), true, utils.NonTransactional); rcvErr != utils.ErrNotFound {
+		t.Error(rcvErr)
+	}
 }

 func testOnStorITCRUDCdrStats(t *testing.T) {
@@ -1671,6 +1709,12 @@ func testOnStorITCRUDSharedGroup(t *testing.T) {
 	// if err = onStor.DataDB().SelectDatabase(onStorCfg); err != nil {
 	// 	t.Error(err)
 	// }
+	if err := onStor.RemoveSharedGroup(sg.Id, utils.NonTransactional); err != nil {
+		t.Error(err)
+	}
+	if _, rcvErr := onStor.GetSharedGroup(sg.Id, true, utils.NonTransactional); rcvErr != utils.ErrNotFound {
+		t.Error(rcvErr)
+	}
 }

 func testOnStorITCRUDActionTriggers(t *testing.T) {
@@ -1897,6 +1941,12 @@ func testOnStorITCRUDCdrStatsQueue(t *testing.T) {
 	} else if !reflect.DeepEqual(sq.Cdrs, rcv.Cdrs) {
 		t.Errorf("Expecting: %v, received: %v", sq.Cdrs, rcv.Cdrs)
 	}
+	if err := onStor.RemoveCdrStatsQueue(sq.GetId()); err != nil {
+		t.Error(err)
+	}
+	if _, rcvErr := onStor.GetCdrStatsQueue(sq.GetId()); rcvErr != utils.ErrNotFound {
+		t.Error(rcvErr)
+	}
 }

 func testOnStorITCRUDSubscribers(t *testing.T) {
--- a/engine/storage_interface.go
+++ b/engine/storage_interface.go
@@ -35,6 +35,7 @@ type Storage interface {
 	Flush(string) error
 	GetKeysForPrefix(string) ([]string, error)
 	RebuildReverseForPrefix(string) error
+	RemoveReverseForPrefix(string) error
 	GetVersions(itm string) (vrs Versions, err error)
 	SetVersions(vrs Versions, overwrite bool) (err error)
 	RemoveVersions(vrs Versions) (err error)
@@ -50,6 +51,7 @@ type DataDB interface {
 	HasDataDrv(string, string) (bool, error)
 	GetRatingPlanDrv(string) (*RatingPlan, error)
 	SetRatingPlanDrv(*RatingPlan) error
+	RemoveRatingPlanDrv(key string) (err error)
 	GetRatingProfileDrv(string) (*RatingProfile, error)
 	SetRatingProfileDrv(*RatingProfile) error
 	RemoveRatingProfileDrv(string) error
@@ -61,21 +63,25 @@ type DataDB interface {
 	UpdateReverseDestination(*Destination, *Destination, string) error
 	GetLCRDrv(string) (*LCR, error)
 	SetLCRDrv(*LCR) error
+	RemoveLCRDrv(id, transactionID string) (err error)
 	SetCdrStatsDrv(*CdrStats) error
 	GetCdrStatsDrv(string) (*CdrStats, error)
 	GetAllCdrStatsDrv() ([]*CdrStats, error)
 	GetDerivedChargersDrv(string) (*utils.DerivedChargers, error)
 	SetDerivedChargers(string, *utils.DerivedChargers, string) error
+	RemoveDerivedChargersDrv(id, transactionID string) (err error)
 	GetActionsDrv(string) (Actions, error)
 	SetActionsDrv(string, Actions) error
 	RemoveActionsDrv(string) error
 	GetSharedGroupDrv(string) (*SharedGroup, error)
 	SetSharedGroupDrv(*SharedGroup) error
+	RemoveSharedGroupDrv(id, transactionID string) (err error)
 	GetActionTriggersDrv(string) (ActionTriggers, error)
 	SetActionTriggersDrv(string, ActionTriggers) error
 	RemoveActionTriggersDrv(string) error
 	GetActionPlan(string, bool, string) (*ActionPlan, error)
 	SetActionPlan(string, *ActionPlan, bool, string) error
+	RemoveActionPlan(key string, transactionID string) error
 	GetAllActionPlans() (map[string]*ActionPlan, error)
 	GetAccountActionPlans(acntID string, skipCache bool, transactionID string) (apIDs []string, err error)
 	SetAccountActionPlans(acntID string, apIDs []string, overwrite bool) (err error)
@@ -87,6 +93,7 @@ type DataDB interface {
 	RemoveAccount(string) error
 	GetCdrStatsQueueDrv(string) (*CDRStatsQueue, error)
 	SetCdrStatsQueueDrv(*CDRStatsQueue) error
+	RemoveCdrStatsQueueDrv(id string) (err error)
 	GetSubscribersDrv() (map[string]*SubscriberData, error)
 	SetSubscriberDrv(string, *SubscriberData) error
 	RemoveSubscriberDrv(string) error
@@ -112,6 +119,7 @@ type DataDB interface {
 	AddLoadHistory(*utils.LoadInstance, int, string) error
 	GetReqFilterIndexesDrv(dbKey string) (indexes map[string]map[string]utils.StringMap, err error)
 	SetReqFilterIndexesDrv(dbKey string, indexes map[string]map[string]utils.StringMap) (err error)
+	RemoveReqFilterIndexesDrv(id string) (err error)
 	MatchReqFilterIndexDrv(dbKey, fieldName, fieldVal string) (itemIDs utils.StringMap, err error)
 	GetStatQueueProfileDrv(tenant string, ID string) (sq *StatQueueProfile, err error)
 	SetStatQueueProfileDrv(sq *StatQueueProfile) (err error)
--- a/engine/storage_map.go
+++ b/engine/storage_map.go
@@ -146,6 +146,54 @@ func (ms *MapStorage) RebuildReverseForPrefix(prefix string) error {
 	return nil
 }

+func (ms *MapStorage) RemoveReverseForPrefix(prefix string) error {
+	// ToDo: should do transaction
+	keys, err := ms.GetKeysForPrefix(prefix)
+	if err != nil {
+		return err
+	}
+	for _, key := range keys {
+		ms.mu.Lock()
+		delete(ms.dict, key)
+		ms.mu.Unlock()
+	}
+	switch prefix {
+	case utils.REVERSE_DESTINATION_PREFIX:
+		keys, err = ms.GetKeysForPrefix(utils.DESTINATION_PREFIX)
+		if err != nil {
+			return err
+		}
+		for _, key := range keys {
+			dest, err := ms.GetDestination(key[len(utils.DESTINATION_PREFIX):], false, utils.NonTransactional)
+			if err != nil {
+				return err
+			}
+			if err := ms.RemoveDestination(dest.Id, utils.NonTransactional); err != nil {
+				return err
+			}
+		}
+	case utils.REVERSE_ALIASES_PREFIX:
+		keys, err = ms.GetKeysForPrefix(utils.ALIASES_PREFIX)
+		if err != nil {
+			return err
+		}
+		for _, key := range keys {
+			al, err := ms.GetAlias(key[len(utils.ALIASES_PREFIX):], false, utils.NonTransactional)
+			if err != nil {
+				return err
+			}
+			if err := ms.RemoveAlias(al.GetId(), utils.NonTransactional); err != nil {
+				return err
+			}
+		}
+	case utils.AccountActionPlansPrefix:
+		return nil
+	default:
+		return utils.ErrInvalidKey
+	}
+	return nil
+}
+
 func (ms *MapStorage) IsDBEmpty() (resp bool, err error) {
 	ms.mu.RLock()
 	defer ms.mu.RUnlock()
@@ -217,6 +265,22 @@ func (ms *MapStorage) SetRatingPlanDrv(rp *RatingPlan) (err error) {
 	return
 }

+func (ms *MapStorage) RemoveRatingPlanDrv(key string) (err error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	for k := range ms.dict {
+		if strings.HasPrefix(k, key) {
+			delete(ms.dict, key)
+			response := 0
+			rpf := &RatingPlan{Id: key}
+			if historyScribe != nil {
+				go historyScribe.Call("HistoryV1.Record", rpf.GetHistoryRecord(), &response)
+			}
+		}
+	}
+	return
+}
+
 func (ms *MapStorage) GetRatingProfileDrv(key string) (rpf *RatingProfile, err error) {
 	ms.mu.RLock()
 	defer ms.mu.RUnlock()
@@ -279,6 +343,13 @@ func (ms *MapStorage) SetLCRDrv(lcr *LCR) (err error) {
 	return
 }

+func (ms *MapStorage) RemoveLCRDrv(id, transactionID string) (err error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	delete(ms.dict, utils.LCR_PREFIX+id)
+	return
+}
+
 func (ms *MapStorage) GetDestination(key string, skipCache bool, transactionID string) (dest *Destination, err error) {
 	ms.mu.RLock()
 	defer ms.mu.RUnlock()
@@ -495,6 +566,13 @@ func (ms *MapStorage) SetSharedGroupDrv(sg *SharedGroup) (err error) {
 	return
 }

+func (ms *MapStorage) RemoveSharedGroupDrv(id, transactionID string) (err error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	delete(ms.dict, utils.SHARED_GROUP_PREFIX+id)
+	return
+}
+
 func (ms *MapStorage) GetAccount(key string) (ub *Account, err error) {
 	ms.mu.RLock()
 	defer ms.mu.RUnlock()
@@ -561,6 +639,14 @@ func (ms *MapStorage) SetCdrStatsQueueDrv(sq *CDRStatsQueue) (err error) {
 	return
 }

+func (ms *MapStorage) RemoveCdrStatsQueueDrv(id string) (err error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+
+	delete(ms.dict, id)
+	return
+}
+
 func (ms *MapStorage) GetSubscribersDrv() (result map[string]*SubscriberData, err error) {
 	ms.mu.RLock()
 	defer ms.mu.RUnlock()
@@ -847,6 +933,15 @@ func (ms *MapStorage) SetActionPlan(key string, ats *ActionPlan, overwrite bool,
 	return
 }

+func (ms *MapStorage) RemoveActionPlan(key string, transactionID string) error {
+	cCommit := cacheCommit(transactionID)
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	delete(ms.dict, utils.ACTION_PLAN_PREFIX+key)
+	cache.RemKey(utils.ACTION_PLAN_PREFIX+key, cCommit, transactionID)
+	return nil
+}
+
 func (ms *MapStorage) GetAllActionPlans() (ats map[string]*ActionPlan, err error) {
 	keys, err := ms.GetKeysForPrefix(utils.ACTION_PLAN_PREFIX)
 	if err != nil {
@@ -995,6 +1090,15 @@ func (ms *MapStorage) SetDerivedChargers(key string, dcs *utils.DerivedChargers,
 	return err
 }

+func (ms *MapStorage) RemoveDerivedChargersDrv(id, transactionID string) (err error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	cCommit := cacheCommit(transactionID)
+	delete(ms.dict, id)
+	cache.RemKey(id, cCommit, transactionID)
+	return
+}
+
 func (ms *MapStorage) SetCdrStatsDrv(cs *CdrStats) error {
 	ms.mu.Lock()
 	defer ms.mu.Unlock()
@@ -1173,6 +1277,14 @@ func (ms *MapStorage) SetReqFilterIndexesDrv(dbKey string, indexes map[string]ma
 	ms.dict[dbKey] = result
 	return
 }
+
+func (ms *MapStorage) RemoveReqFilterIndexesDrv(id string) (err error) {
+	ms.mu.Lock()
+	defer ms.mu.Unlock()
+	delete(ms.dict, id)
+	return
+}
+
 func (ms *MapStorage) MatchReqFilterIndexDrv(dbKey, fldName, fldVal string) (itemIDs utils.StringMap, err error) {
 	ms.mu.RLock()
 	defer ms.mu.RUnlock()
--- a/engine/storage_mongo_datadb.go
+++ b/engine/storage_mongo_datadb.go
@@ -428,6 +428,66 @@ func (ms *MongoStorage) RebuildReverseForPrefix(prefix string) (err error) {
 	return nil
 }

+func (ms *MongoStorage) RemoveReverseForPrefix(prefix string) (err error) {
+	if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.REVERSE_ALIASES_PREFIX, utils.AccountActionPlansPrefix}, prefix) {
+		return utils.ErrInvalidKey
+	}
+	colName, ok := ms.getColNameForPrefix(prefix)
+	if !ok {
+		return utils.ErrInvalidKey
+	}
+	session, col := ms.conn(colName)
+	defer session.Close()
+	if _, err := col.RemoveAll(bson.M{}); err != nil {
+		return err
+	}
+	var keys []string
+	switch prefix {
+	case utils.REVERSE_DESTINATION_PREFIX:
+		if keys, err = ms.GetKeysForPrefix(utils.DESTINATION_PREFIX); err != nil {
+			return
+		}
+		for _, key := range keys {
+			dest, err := ms.GetDestination(key[len(utils.DESTINATION_PREFIX):], true, utils.NonTransactional)
+			if err != nil {
+				return err
+			}
+			if err := ms.RemoveDestination(dest.Id, utils.NonTransactional); err != nil {
+				return err
+			}
+		}
+	case utils.REVERSE_ALIASES_PREFIX:
+		if keys, err = ms.GetKeysForPrefix(utils.ALIASES_PREFIX); err != nil {
+			return
+		}
+		for _, key := range keys {
+			al, err := ms.GetAlias(key[len(utils.ALIASES_PREFIX):], true, utils.NonTransactional)
+			if err != nil {
+				return err
+			}
+			if err := ms.RemoveAlias(al.GetId(), utils.NonTransactional); err != nil {
+				return err
+			}
+		}
+	case utils.AccountActionPlansPrefix:
+		if keys, err = ms.GetKeysForPrefix(utils.ACTION_PLAN_PREFIX); err != nil {
+			return
+		}
+		for _, key := range keys {
+			apl, err := ms.GetActionPlan(key[len(utils.ACTION_PLAN_PREFIX):], true, utils.NonTransactional)
+			if err != nil {
+				return err
+			}
+			for acntID := range apl.AccountIDs {
+				if err = ms.RemAccountActionPlans(acntID, []string{apl.Id}); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
 func (ms *MongoStorage) IsDBEmpty() (resp bool, err error) {
 	session := ms.session.Copy()
 	defer session.Close()
@@ -693,6 +753,39 @@ func (ms *MongoStorage) SetRatingPlanDrv(rp *RatingPlan) error {
 	return err
 }

+func (ms *MongoStorage) RemoveRatingPlanDrv(key string) error {
+	session, col := ms.conn(colRpl)
+	defer session.Close()
+	var kv struct {
+		Key   string
+		Value []byte
+	}
+	var rp RatingPlan
+	iter := col.Find(bson.M{"key": key}).Iter()
+	for iter.Next(&kv) {
+		if err := col.Remove(bson.M{"key": kv.Key}); err != nil {
+			return err
+		}
+		b := bytes.NewBuffer(kv.Value)
+		r, err := zlib.NewReader(b)
+		if err != nil {
+			return err
+		}
+		out, err := ioutil.ReadAll(r)
+		if err != nil {
+			return err
+		}
+		if err = ms.ms.Unmarshal(out, &rp); err != nil {
+			return err
+		}
+		if err == nil && historyScribe != nil {
+			var response int
+			go historyScribe.Call("HistoryV1.Record", rp.GetHistoryRecord(), &response)
+		}
+	}
+	return iter.Close()
+}
+
 func (ms *MongoStorage) GetRatingProfileDrv(key string) (rp *RatingProfile, err error) {
 	session, col := ms.conn(colRpf)
 	defer session.Close()
@@ -766,6 +859,13 @@ func (ms *MongoStorage) SetLCRDrv(lcr *LCR) (err error) {
 	return
 }

+func (ms *MongoStorage) RemoveLCRDrv(id, transactionID string) (err error) {
+	session, col := ms.conn(colLcr)
+	defer session.Close()
+	err = col.Remove(bson.M{"key": id})
+	return err
+}
+
 func (ms *MongoStorage) GetDestination(key string, skipCache bool, transactionID string) (result *Destination, err error) {
 	cacheKey := utils.DESTINATION_PREFIX + key
 	if !skipCache {
@@ -1013,6 +1113,13 @@ func (ms *MongoStorage) SetSharedGroupDrv(sg *SharedGroup) (err error) {
 	return
 }

+func (ms *MongoStorage) RemoveSharedGroupDrv(id, transactionID string) (err error) {
+	session, col := ms.conn(colShg)
+	defer session.Close()
+	err = col.Remove(bson.M{"id": id})
+	return err
+}
+
 func (ms *MongoStorage) GetAccount(key string) (result *Account, err error) {
 	result = new(Account)
 	session, col := ms.conn(colAcc)
@@ -1078,6 +1185,15 @@ func (ms *MongoStorage) SetCdrStatsQueueDrv(sq *CDRStatsQueue) (err error) {
 	return
 }

+func (ms *MongoStorage) RemoveCdrStatsQueueDrv(id string) (err error) {
+	session, col := ms.conn(colStq)
+	defer session.Close()
+	if err = col.Remove(bson.M{"key": id}); err != nil && err != mgo.ErrNotFound {
+		return
+	}
+	return nil
+}
+
 func (ms *MongoStorage) GetSubscribersDrv() (result map[string]*SubscriberData, err error) {
 	session, col := ms.conn(colPbs)
 	defer session.Close()
@@ -1498,6 +1614,19 @@ func (ms *MongoStorage) SetActionPlan(key string, ats *ActionPlan, overwrite boo
 	return err
 }

+func (ms *MongoStorage) RemoveActionPlan(key string, transactionID string) error {
+	session, col := ms.conn(colApl)
+	defer session.Close()
+	dbKey := utils.ACTION_PLAN_PREFIX + key
+	cCommit := cacheCommit(transactionID)
+	cache.RemKey(dbKey, cCommit, transactionID)
+	err := col.Remove(bson.M{"key": key})
+	if err != nil && err == mgo.ErrNotFound {
+		err = nil
+	}
+	return err
+}
+
 func (ms *MongoStorage) GetAllActionPlans() (ats map[string]*ActionPlan, err error) {
 	keys, err := ms.GetKeysForPrefix(utils.ACTION_PLAN_PREFIX)
 	if err != nil {
@@ -1659,6 +1788,18 @@ func (ms *MongoStorage) SetDerivedChargers(key string, dcs *utils.DerivedCharger
 	return err
 }

+func (ms *MongoStorage) RemoveDerivedChargersDrv(id, transactionID string) (err error) {
+	cCommit := cacheCommit(transactionID)
+	cacheKey := utils.DERIVEDCHARGERS_PREFIX + id
+	session, col := ms.conn(colDcs)
+	defer session.Close()
+	if err = col.Remove(bson.M{"key": id}); err != nil && err != mgo.ErrNotFound {
+		return
+	}
+	cache.RemKey(cacheKey, cCommit, transactionID)
+	return nil
+}
+
 func (ms *MongoStorage) SetCdrStatsDrv(cs *CdrStats) error {
 	session, col := ms.conn(colCrs)
 	defer session.Close()
@@ -1803,6 +1944,15 @@ func (ms *MongoStorage) SetReqFilterIndexesDrv(dbKey string, indexes map[string]
 	return
 }

+func (ms *MongoStorage) RemoveReqFilterIndexesDrv(id string) (err error) {
+	session, col := ms.conn(colRFI)
+	defer session.Close()
+	if err = col.Remove(bson.M{"key": id}); err != nil {
+		return
+	}
+	return nil
+}
+
 func (ms *MongoStorage) MatchReqFilterIndexDrv(dbKey, fldName, fldVal string) (itemIDs utils.StringMap, err error) {
 	session, col := ms.conn(colRFI)
 	defer session.Close()
--- a/engine/storage_redis.go
+++ b/engine/storage_redis.go
@@ -191,6 +191,66 @@ func (rs *RedisStorage) RebuildReverseForPrefix(prefix string) (err error) {
 	return nil
 }

+func (rs *RedisStorage) RemoveReverseForPrefix(prefix string) (err error) {
+	if !utils.IsSliceMember([]string{utils.REVERSE_DESTINATION_PREFIX, utils.REVERSE_ALIASES_PREFIX, utils.AccountActionPlansPrefix}, prefix) {
+		return utils.ErrInvalidKey
+	}
+	var keys []string
+	keys, err = rs.GetKeysForPrefix(prefix)
+	if err != nil {
+		return
+	}
+	for _, key := range keys {
+		if err = rs.Cmd("DEL", key).Err; err != nil {
+			return
+		}
+	}
+	switch prefix {
+	case utils.REVERSE_DESTINATION_PREFIX:
+		if keys, err = rs.GetKeysForPrefix(utils.DESTINATION_PREFIX); err != nil {
+			return
+		}
+		for _, key := range keys {
+			dest, err := rs.GetDestination(key[len(utils.DESTINATION_PREFIX):], true, utils.NonTransactional)
+			if err != nil {
+				return err
+			}
+			if err := rs.RemoveDestination(dest.Id, utils.NonTransactional); err != nil {
+				return err
+			}
+		}
+	case utils.REVERSE_ALIASES_PREFIX:
+		if keys, err = rs.GetKeysForPrefix(utils.ALIASES_PREFIX); err != nil {
+			return
+		}
+		for _, key := range keys {
+			al, err := rs.GetAlias(key[len(utils.ALIASES_PREFIX):], true, utils.NonTransactional)
+			if err != nil {
+				return err
+			}
+			if err := rs.RemoveAlias(al.GetId(), utils.NonTransactional); err != nil {
+				return err
+			}
+		}
+	case utils.AccountActionPlansPrefix:
+		if keys, err = rs.GetKeysForPrefix(utils.ACTION_PLAN_PREFIX); err != nil {
+			return
+		}
+		for _, key := range keys {
+			apl, err := rs.GetActionPlan(key[len(utils.ACTION_PLAN_PREFIX):], true, utils.NonTransactional) // skipCache on get since loader checks and caches empty data for loaded objects
+			if err != nil {
+				return err
+			}
+			for acntID := range apl.AccountIDs {
+				if err = rs.RemAccountActionPlans(acntID, []string{apl.Id}); err != nil {
+					return err
+				}
+			}
+		}
+	}
+	return nil
+}
+
 func (rs *RedisStorage) GetKeysForPrefix(prefix string) ([]string, error) {
 	r := rs.Cmd("KEYS", prefix+"*")
 	if r.Err != nil {
@@ -256,6 +316,24 @@ func (rs *RedisStorage) SetRatingPlanDrv(rp *RatingPlan) (err error) {
 	return
 }

+func (rs *RedisStorage) RemoveRatingPlanDrv(key string) error {
+	keys, err := rs.Cmd("KEYS", utils.RATING_PLAN_PREFIX+key+"*").List()
+	if err != nil {
+		return err
+	}
+	for _, key := range keys {
+		if err = rs.Cmd("DEL", key).Err; err != nil {
+			return err
+		}
+		rpf := &RatingProfile{Id: key}
+		if historyScribe != nil {
+			response := 0
+			go historyScribe.Call("HistoryV1.Record", rpf.GetHistoryRecord(true), &response)
+		}
+	}
+	return nil
+}
+
 func (rs *RedisStorage) GetRatingProfileDrv(key string) (rpf *RatingProfile, err error) {
 	key = utils.RATING_PROFILE_PREFIX + key
 	var values []byte
@@ -332,6 +410,12 @@ func (rs *RedisStorage) SetLCRDrv(lcr *LCR) (err error) {
 	return
 }

+func (rs *RedisStorage) RemoveLCRDrv(id, transactionID string) (err error) {
+	dbKey := utils.LCR_PREFIX + id
+	err = rs.Cmd("DEL", dbKey).Err
+	return err
+}
+
 // GetDestination retrieves a destination with id from  tp_db
 func (rs *RedisStorage) GetDestination(key string, skipCache bool, transactionID string) (dest *Destination, err error) {
 	key = utils.DESTINATION_PREFIX + key
@@ -548,6 +632,14 @@ func (rs *RedisStorage) SetSharedGroupDrv(sg *SharedGroup) (err error) {
 	return
 }

+func (rs *RedisStorage) RemoveSharedGroupDrv(id, transactionID string) (err error) {
+	cCommit := cacheCommit(transactionID)
+	dbKey := utils.SHARED_GROUP_PREFIX + id
+	err = rs.Cmd("DEL", dbKey).Err
+	cache.RemKey(dbKey, cCommit, transactionID)
+	return err
+}
+
 func (rs *RedisStorage) GetAccount(key string) (*Account, error) {
 	rpl := rs.Cmd("GET", utils.ACCOUNT_PREFIX+key)
 	if rpl.Err != nil {
@@ -612,6 +704,12 @@ func (rs *RedisStorage) SetCdrStatsQueueDrv(sq *CDRStatsQueue) (err error) {
 	return rs.Cmd("SET", utils.CDR_STATS_QUEUE_PREFIX+sq.GetId(), result).Err
 }

+func (rs *RedisStorage) RemoveCdrStatsQueueDrv(id string) (err error) {
+	dbKey := utils.CDR_STATS_QUEUE_PREFIX + id
+	err = rs.Cmd("DEL", dbKey).Err
+	return err
+}
+
 func (rs *RedisStorage) GetSubscribersDrv() (result map[string]*SubscriberData, err error) {
 	keys, err := rs.Cmd("KEYS", utils.PUBSUB_SUBSCRIBERS_PREFIX+"*").List()
 	if err != nil {
@@ -948,6 +1046,13 @@ func (rs *RedisStorage) GetActionPlan(key string, skipCache bool, transactionID
 	cache.Set(key, ats, cacheCommit(transactionID), transactionID)
 	return
 }
+func (rs *RedisStorage) RemoveActionPlan(key string, transactionID string) error {
+	cCommit := cacheCommit(transactionID)
+	dbKey := utils.ACTION_PLAN_PREFIX + key
+	err := rs.Cmd("DEL", dbKey).Err
+	cache.RemKey(dbKey, cCommit, transactionID)
+	return err
+}

 func (rs *RedisStorage) SetActionPlan(key string, ats *ActionPlan, overwrite bool, transactionID string) (err error) {
 	cCommit := cacheCommit(transactionID)
@@ -1121,6 +1226,16 @@ func (rs *RedisStorage) SetDerivedChargers(key string, dcs *utils.DerivedCharger
 	return
 }

+func (rs *RedisStorage) RemoveDerivedChargersDrv(id, transactionID string) (err error) {
+	cCommit := cacheCommit(transactionID)
+	key := utils.DERIVEDCHARGERS_PREFIX + id
+	if err = rs.Cmd("DEL", key).Err; err != nil {
+		return err
+	}
+	cache.RemKey(key, cCommit, transactionID)
+	return
+}
+
 func (rs *RedisStorage) SetCdrStatsDrv(cs *CdrStats) error {
 	marshaled, err := rs.ms.Marshal(cs)
 	if err != nil {
@@ -1295,6 +1410,13 @@ func (rs *RedisStorage) SetReqFilterIndexesDrv(dbKey string, indexes map[string]
 	return rs.Cmd("HMSET", dbKey, mp).Err
 }

+func (rs *RedisStorage) RemoveReqFilterIndexesDrv(id string) (err error) {
+	if err = rs.Cmd("DEL", id).Err; err != nil {
+		return err
+	}
+	return
+}
+
 func (rs *RedisStorage) MatchReqFilterIndexDrv(dbKey, fldName, fldVal string) (itemIDs utils.StringMap, err error) {
 	fieldValKey := utils.ConcatenatedKey(fldName, fldVal)
 	// Not found in cache, check in DB
--- a/engine/tp_reader.go
+++ b/engine/tp_reader.go
@@ -2653,3 +2653,351 @@ func (tpr *TpReader) GetLoadedIds(categ string) ([]string, error) {
 	}
 	return nil, errors.New("Unsupported load category")
 }
+
+func (tpr *TpReader) RemoveFromDatabase(verbose, disable_reverse bool) (err error) {
+	for _, d := range tpr.destinations {
+		err = tpr.dm.DataDB().RemoveDestination(d.Id, utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", d.Id, " : ", d.Prefixes)
+		}
+	}
+	if verbose {
+		log.Print("Reverse Destinations:")
+		for id, vals := range tpr.revDests {
+			log.Printf("\t %s : %+v", id, vals)
+		}
+	}
+	if verbose {
+		log.Print("Rating Plans:")
+	}
+	for _, rp := range tpr.ratingPlans {
+		err = tpr.dm.RemoveRatingPlan(rp.Id, utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", rp.Id)
+		}
+	}
+	if verbose {
+		log.Print("Rating Profiles:")
+	}
+	for _, rp := range tpr.ratingProfiles {
+		err = tpr.dm.RemoveRatingProfile(rp.Id, utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", rp.Id)
+		}
+	}
+	if verbose {
+		log.Print("Action Plans:")
+	}
+	for k, _ := range tpr.actionPlans {
+		err = tpr.dm.DataDB().RemoveActionPlan(k, utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("Account Action Plans:")
+		for id, vals := range tpr.acntActionPlans {
+			log.Printf("\t %s : %+v", id, vals)
+		}
+	}
+	if verbose {
+		log.Print("Action Triggers:")
+	}
+	for k, _ := range tpr.actionsTriggers {
+		err = tpr.dm.RemoveActionTriggers(k, utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("Shared Groups:")
+	}
+	for k, _ := range tpr.sharedGroups {
+		err = tpr.dm.RemoveSharedGroup(k, utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("LCR Rules:")
+	}
+	for k, lcr := range tpr.lcrs {
+		err = tpr.dm.RemoveLCR(lcr.GetId(), utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("Actions:")
+	}
+	for k, _ := range tpr.actions {
+		err = tpr.dm.RemoveActions(k, utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", k)
+		}
+	}
+	if verbose {
+		log.Print("Account Actions:")
+	}
+	for _, ub := range tpr.accountActions {
+		err = tpr.dm.DataDB().RemoveAccount(ub.ID)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Println("\t", ub.ID)
+		}
+	}
+	if verbose {
+		log.Print("Derived Chargers:")
+	}
+	for key, _ := range tpr.derivedChargers {
+		err = tpr.dm.RemoveDerivedChargers(key, utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", key)
+		}
+	}
+	if verbose {
+		log.Print("CDR Stats Queues:")
+	}
+	for _, sq := range tpr.cdrStats {
+		err = tpr.dm.RemoveCdrStatsQueue(sq.Id)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", sq.Id)
+		}
+	}
+	if verbose {
+		log.Print("Users:")
+	}
+	for _, u := range tpr.users {
+		err = tpr.dm.RemoveUser(u.GetId())
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", u.GetId())
+		}
+	}
+	if verbose {
+		log.Print("Aliases:")
+	}
+	for _, al := range tpr.aliases {
+		err = tpr.dm.DataDB().RemoveAlias(al.GetId(), utils.NonTransactional)
+		if err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", al.GetId())
+		}
+	}
+	if verbose {
+		log.Print("Reverse Aliases:")
+		for id, vals := range tpr.revAliases {
+			log.Printf("\t %s : %+v", id, vals)
+		}
+	}
+	if verbose {
+		log.Print("Filters:")
+	}
+	for _, tpTH := range tpr.filters {
+		if err = tpr.dm.RemoveFilter(tpTH.Tenant, tpTH.ID, utils.NonTransactional); err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", tpTH.Tenant)
+		}
+	}
+	if verbose {
+		log.Print("ResourceProfiles:")
+	}
+	for _, tpRsp := range tpr.resProfiles {
+		if err = tpr.dm.RemoveResourceProfile(tpRsp.Tenant, tpRsp.ID, utils.NonTransactional); err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", tpRsp.Tenant)
+		}
+	}
+	if verbose {
+		log.Print("Resources:")
+	}
+	for _, rTid := range tpr.resources {
+		if err = tpr.dm.RemoveResource(rTid.Tenant, rTid.ID, utils.NonTransactional); err != nil {
+			return
+		}
+		if verbose {
+			log.Print("\t", rTid.TenantID())
+		}
+	}
+	if verbose {
+		log.Print("StatQueueProfiles:")
+	}
+	for _, tpST := range tpr.sqProfiles {
+		if err = tpr.dm.RemoveStatQueueProfile(tpST.Tenant, tpST.ID, utils.NonTransactional); err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", tpST.Tenant)
+		}
+	}
+	if verbose {
+		log.Print("StatQueues:")
+	}
+	for _, sqTntID := range tpr.statQueues {
+		if err = tpr.dm.RemStatQueue(sqTntID.Tenant, sqTntID.ID, utils.NonTransactional); err != nil {
+			return
+		}
+		if verbose {
+			log.Print("\t", sqTntID.Tenant)
+		}
+	}
+	if verbose {
+		log.Print("ThresholdProfiles:")
+	}
+	for _, tpTH := range tpr.thProfiles {
+		if err = tpr.dm.RemoveThresholdProfile(tpTH.Tenant, tpTH.ID, utils.NonTransactional); err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", tpTH.Tenant)
+		}
+	}
+	if verbose {
+		log.Print("Thresholds:")
+	}
+	for _, thd := range tpr.thresholds {
+		if err = tpr.dm.RemoveThreshold(thd.Tenant, thd.ID, utils.NonTransactional); err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", thd.Tenant)
+		}
+	}
+
+	if verbose {
+		log.Print("SupplierProfiles:")
+	}
+	for _, tpTH := range tpr.sppProfiles {
+		if err = tpr.dm.RemoveSupplierProfile(tpTH.Tenant, tpTH.ID, utils.NonTransactional); err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", tpTH.Tenant)
+		}
+	}
+	if verbose {
+		log.Print("Timings:")
+	}
+	for _, t := range tpr.timings {
+		if err = tpr.dm.RemoveTiming(t.ID, utils.NonTransactional); err != nil {
+			return err
+		}
+		if verbose {
+			log.Print("\t", t.ID)
+		}
+	}
+	if !disable_reverse {
+		if len(tpr.destinations) > 0 {
+			if verbose {
+				log.Print("Removing reverse destinations")
+			}
+			if err = tpr.dm.DataDB().RemoveReverseForPrefix(utils.REVERSE_DESTINATION_PREFIX); err != nil {
+				return err
+			}
+		}
+		if len(tpr.acntActionPlans) > 0 {
+			if verbose {
+				log.Print("Removing account action plans")
+			}
+			if err = tpr.dm.DataDB().RemoveReverseForPrefix(utils.AccountActionPlansPrefix); err != nil {
+				return err
+			}
+		}
+		if len(tpr.aliases) > 0 {
+			if verbose {
+				log.Print("Removing reverse aliases")
+			}
+			if err = tpr.dm.DataDB().RemoveReverseForPrefix(utils.REVERSE_ALIASES_PREFIX); err != nil {
+				return err
+			}
+		}
+		if verbose {
+			log.Print("Indexing resource profiles")
+		}
+		for tenant, fltrIdxer := range tpr.resIndexers {
+			if err := tpr.dm.RemoveReqFilterIndexes(GetDBIndexKey(fltrIdxer.itemType, fltrIdxer.dbKeySuffix, false)); err != nil {
+				return err
+			}
+			if verbose {
+				log.Printf("Tenant: %s, keys %+v", tenant, fltrIdxer.ChangedKeys(false).Slice())
+			}
+		}
+
+		if verbose {
+			log.Print("StatQueue filter indexes:")
+		}
+		for tenant, fltrIdxer := range tpr.sqpIndexers {
+			if err := tpr.dm.RemoveReqFilterIndexes(GetDBIndexKey(fltrIdxer.itemType, fltrIdxer.dbKeySuffix, false)); err != nil {
+				return err
+			}
+			if verbose {
+				log.Printf("Tenant: %s, keys %+v", tenant, fltrIdxer.ChangedKeys(true).Slice())
+			}
+		}
+
+		if verbose {
+			log.Print("Threshold filter indexes:")
+		}
+		for tenant, fltrIdxer := range tpr.thdsIndexers {
+			if err := tpr.dm.RemoveReqFilterIndexes(GetDBIndexKey(fltrIdxer.itemType, fltrIdxer.dbKeySuffix, false)); err != nil {
+				return err
+			}
+			if verbose {
+				log.Printf("Tenant: %s, keys %+v", tenant, fltrIdxer.ChangedKeys(false).Slice())
+			}
+		}
+
+		if verbose {
+			log.Print("Indexing Supplier Profiles")
+		}
+		for tenant, fltrIdxer := range tpr.sppIndexers {
+			if err := tpr.dm.RemoveReqFilterIndexes(GetDBIndexKey(fltrIdxer.itemType, fltrIdxer.dbKeySuffix, false)); err != nil {
+				return err
+			}
+			if verbose {
+				log.Printf("Tenant: %s, keys %+v", tenant, fltrIdxer.ChangedKeys(true).Slice())
+			}
+		}
+	}
+	return
+}