diff --git a/engine/version.go b/engine/version.go
index 23b4f4232..0128f1f7d 100644
--- a/engine/version.go
+++ b/engine/version.go
@@ -143,7 +143,7 @@ func CurrentStorDBVersions() Versions {
 		utils.TpFilters:          1,
 		utils.TpDestinationRates: 1,
 		utils.TpActionTriggers:   1,
-		utils.TpAccountActions:   1,
+		utils.TpAccountActionsV:  1,
 		utils.TpActionPlans:      1,
 		utils.TpActions:          1,
 		utils.TpDerivedCharges:   1,
diff --git a/migrator/alias.go b/migrator/alias.go
index aa95945fb..775d0039a 100644
--- a/migrator/alias.go
+++ b/migrator/alias.go
@@ -20,6 +20,7 @@ package migrator
 
 import (
 	"fmt"
+	//"log"
 	"strings"
 
 	"github.com/cgrates/cgrates/engine"
@@ -50,36 +51,43 @@ func (m *Migrator) migrateCurrentAlias() (err error) {
 	return
 }
 
-func (m *Migrator) migrateCurrentReverseAlias() (err error) {
-	var ids []string
-	ids, err = m.dmIN.DataDB().GetKeysForPrefix(utils.REVERSE_ALIASES_PREFIX)
-	if err != nil {
-		return err
-	}
-	for _, id := range ids {
-		idg := strings.TrimPrefix(id, utils.REVERSE_ALIASES_PREFIX)
+// func (m *Migrator) migrateCurrentReverseAlias() (err error) {
+// 	var ids []string
+// 	ids, err = m.dmIN.DataDB().GetKeysForPrefix(utils.REVERSE_ALIASES_PREFIX)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	log.Print("ids: ", ids)
+// 	for _, id := range ids {
+// 		idg := strings.TrimPrefix(id, utils.REVERSE_ALIASES_PREFIX)
+// 		usrs, err := m.dmIN.DataDB().GetReverseAlias(idg, true, utils.NonTransactional)
+// 		if err != nil {
+// 			return err
+// 		}
+// 		log.Print(id)
+// 		log.Print(idg)
+// 		log.Print("values: ", usrs)
 
-		usrs, err := m.dmIN.DataDB().GetReverseAlias(idg, true, utils.NonTransactional)
-		if err != nil {
-			return err
-		}
-		for _, usr := range usrs {
-			alias, err := m.dmIN.DataDB().GetAlias(usr, true, utils.NonTransactional)
-			if err != nil {
-				return err
-			}
-			if alias != nil {
-				if m.dryRun != true {
-					if err := m.dmOut.DataDB().SetReverseAlias(alias, utils.NonTransactional); err != nil {
-						return err
-					}
-					m.stats[utils.ReverseAlias] += 1
-				}
-			}
-		}
-	}
-	return
-}
+// 		for _, usr := range usrs {
+// 			log.Print(usr)
+
+// 			alias, err := m.dmIN.DataDB().GetAlias(usr, true, utils.NonTransactional)
+// 			if err != nil {
+// 				log.Print("erorr")
+// 				return err
+// 			}
+// 			if alias != nil {
+// 				if m.dryRun != true {
+// 					if err := m.dmOut.DataDB().SetReverseAlias(alias, utils.NonTransactional); err != nil {
+// 						return err
+// 					}
+// 					m.stats[utils.ReverseAlias] += 1
+// 				}
+// 			}
+// 		}
+// 	}
+// 	return
+// }
 
 func (m *Migrator) migrateAlias() (err error) {
 	var vrs engine.Versions
@@ -110,29 +118,29 @@ func (m *Migrator) migrateAlias() (err error) {
 }
 
 func (m *Migrator) migrateReverseAlias() (err error) {
-	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
-	if err != nil {
-		return utils.NewCGRError(utils.Migrator,
-			utils.ServerErrorCaps,
-			err.Error(),
-			fmt.Sprintf("error: <%s> when querying oldDataDB for versions", err.Error()))
-	} else if len(vrs) == 0 {
-		return utils.NewCGRError(utils.Migrator,
-			utils.MandatoryIEMissingCaps,
-			utils.UndefinedVersion,
-			"version number is not defined for ActionTriggers model")
-	}
-	switch vrs[utils.ReverseAlias] {
-	case current[utils.ReverseAlias]:
-		if m.sameDataDB {
-			return
-		}
-		if err := m.migrateCurrentReverseAlias(); err != nil {
-			return err
-		}
-		return
-	}
+	// var vrs engine.Versions
+	// current := engine.CurrentDataDBVersions()
+	// vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	// if err != nil {
+	// 	return utils.NewCGRError(utils.Migrator,
+	// 		utils.ServerErrorCaps,
+	// 		err.Error(),
+	// 		fmt.Sprintf("error: <%s> when querying oldDataDB for versions", err.Error()))
+	// } else if len(vrs) == 0 {
+	// 	return utils.NewCGRError(utils.Migrator,
+	// 		utils.MandatoryIEMissingCaps,
+	// 		utils.UndefinedVersion,
+	// 		"version number is not defined for ActionTriggers model")
+	// }
+	// switch vrs[utils.ReverseAlias] {
+	// case current[utils.ReverseAlias]:
+	// 	if m.sameDataDB {
+	// 		return
+	// 	}
+	// 	if err := m.migrateCurrentReverseAlias(); err != nil {
+	// 		return err
+	// 	}
+	// 	return
+	// }
 	return
 }
diff --git a/migrator/derived_chargers.go b/migrator/derived_chargers.go
index 8ec73ad3f..b8996ef29 100644
--- a/migrator/derived_chargers.go
+++ b/migrator/derived_chargers.go
@@ -40,7 +40,7 @@ func (m *Migrator) migrateCurrentDerivedChargers() (err error) {
 		}
 		if drc != nil {
 			if m.dryRun != true {
-				if err := m.dmOut.DataDB().SetDerivedChargers(id, drc, utils.NonTransactional); err != nil {
+				if err := m.dmOut.DataDB().SetDerivedChargers(idg, drc, utils.NonTransactional); err != nil {
 					return err
 				}
 				m.stats[utils.DerivedChargersV] += 1
diff --git a/migrator/destinations.go b/migrator/destinations.go
index e1a1bf53e..1582f047c 100644
--- a/migrator/destinations.go
+++ b/migrator/destinations.go
@@ -80,27 +80,34 @@ func (m *Migrator) migrateDestinations() (err error) {
 
 func (m *Migrator) migrateCurrentReverseDestinations() (err error) {
 	var ids []string
+	var mapids []string
+	mappedvals := make(map[string][]string)
 	ids, err = m.dmIN.DataDB().GetKeysForPrefix(utils.REVERSE_DESTINATION_PREFIX)
 	if err != nil {
 		return err
 	}
 	for _, id := range ids {
+		id := strings.TrimPrefix(id, utils.REVERSE_DESTINATION_PREFIX)
 		rdst, err := m.dmIN.DataDB().GetReverseDestination(id, true, utils.NonTransactional)
 		if err != nil {
 			return err
 		}
-		for _, id := range rdst {
-			rdst, err := m.dmIN.DataDB().GetDestination(id, true, utils.NonTransactional)
-			if err != nil {
-				return err
+		if rdst != nil {
+			for _, rdid := range rdst {
+				mapids = append(mapids, rdid)
+				mappedvals[rdid] = append(mappedvals[rdid], id)
 			}
-			if rdst != nil {
-				if m.dryRun != true {
-					if err := m.dmOut.DataDB().SetReverseDestination(rdst, utils.NonTransactional); err != nil {
-						return err
-					}
-					m.stats[utils.ReverseDestinations] += 1
+		}
+	}
+	for _, id := range mapids {
+		dst := &engine.Destination{Id: id, Prefixes: mappedvals[id]}
+
+		if dst != nil {
+			if m.dryRun != true {
+				if err := m.dmOut.DataDB().SetReverseDestination(dst, utils.NonTransactional); err != nil {
+					return err
 				}
+				m.stats[utils.ReverseDestinations] += 1
 			}
 		}
 	}
diff --git a/migrator/request_filter.go b/migrator/filters.go
similarity index 84%
rename from migrator/request_filter.go
rename to migrator/filters.go
index cab97f16a..e30941f43 100644
--- a/migrator/request_filter.go
+++ b/migrator/filters.go
@@ -22,25 +22,27 @@ import (
 	"fmt"
 	"strings"
 
+	"github.com/cgrates/cgrates/config"
 	"github.com/cgrates/cgrates/engine"
 	"github.com/cgrates/cgrates/utils"
 )
 
 func (m *Migrator) migrateCurrentRequestFilter() (err error) {
 	var ids []string
-	ids, err = m.dmIN.DataDB().GetKeysForPrefix("request_filter_indexes")
+	tenant := config.CgrConfig().DefaultTenant
+	ids, err = m.dmIN.DataDB().GetKeysForPrefix(utils.FilterPrefix)
 	if err != nil {
 		return err
 	}
 	for _, id := range ids {
-		idg := strings.TrimPrefix(id, "request_filter_indexes")
-		rq, err := m.dmIN.GetReqFilterIndexes(idg)
+		idg := strings.TrimPrefix(id, utils.FilterPrefix+tenant+":")
+		fl, err := m.dmIN.GetFilter(tenant, idg, true, utils.NonTransactional)
 		if err != nil {
 			return err
 		}
-		if rq != nil {
+		if fl != nil {
 			if m.dryRun != true {
-				if err := m.dmOut.SetReqFilterIndexes(id, rq); err != nil {
+				if err := m.dmOut.SetFilter(fl); err != nil {
 					return err
 				}
 				m.stats[utils.RQF] += 1
diff --git a/migrator/migrator.go b/migrator/migrator.go
index e98bef1c5..289785184 100755
--- a/migrator/migrator.go
+++ b/migrator/migrator.go
@@ -165,8 +165,8 @@ func (m *Migrator) Migrate(taskIDs []string) (err error, stats map[string]int) {
 			//TPS
 		case utils.MetaTpRatingPlans:
 			err = m.migrateTPratingplans()
-		case utils.MetaTpLcrs:
-			err = m.migrateTPlcrs()
+		case utils.MetaTpLCRRules:
+			err = m.migrateTpLCRRules()
 		case utils.MetaTpFilters:
 			err = m.migrateTPfilters()
 		case utils.MetaTpDestinationRates:
@@ -179,7 +179,7 @@ func (m *Migrator) Migrate(taskIDs []string) (err error, stats map[string]int) {
 			err = m.migrateTPactionplans()
 		case utils.MetaTpActions:
 			err = m.migrateTPactions()
-		case utils.MetaTpDerivedCharges:
+		case utils.MetaTpDerivedChargers:
 			err = m.migrateTPderivedchargers()
 		case utils.MetaTpThresholds:
 			err = m.migrateTPthresholds()
@@ -201,8 +201,6 @@ func (m *Migrator) Migrate(taskIDs []string) (err error, stats map[string]int) {
 			err = m.migrateTPaliases()
 		case utils.MetaTpUsers:
 			err = m.migrateTPusers()
-		case utils.MetaTpDerivedChargersV:
-			err = m.migrateTPderivedchargers()
 		case utils.MetaTpCdrStats:
 			err = m.migrateTPcdrstats()
 		case utils.MetaTpDestinations:
@@ -281,8 +279,8 @@ func (m *Migrator) Migrate(taskIDs []string) (err error, stats map[string]int) {
 			if err := m.migrateTPratingplans(); err != nil {
 				log.Print("ERROR: ", utils.MetaTpRatingPlans, " ", err)
 			}
-			if err := m.migrateTPlcrs(); err != nil {
-				log.Print("ERROR: ", utils.MetaTpLcrs, " ", err)
+			if err := m.migrateTpLCRRules(); err != nil {
+				log.Print("ERROR: ", utils.MetaTpLCRRules, " ", err)
 			}
 			if err := m.migrateTPfilters(); err != nil {
 				log.Print("ERROR: ", utils.MetaTpFilters, " ", err)
@@ -303,7 +301,7 @@ func (m *Migrator) Migrate(taskIDs []string) (err error, stats map[string]int) {
 				log.Print("ERROR: ", utils.MetaTpActions, " ", err)
 			}
 			if err := m.migrateTPderivedchargers(); err != nil {
-				log.Print("ERROR: ", utils.MetaTpDerivedCharges, " ", err)
+				log.Print("ERROR: ", utils.MetaTpDerivedChargers, " ", err)
 			}
 			if err := m.migrateTPthresholds(); err != nil {
 				log.Print("ERROR: ", utils.MetaTpThresholds, " ", err)
diff --git a/migrator/migrator_it_test.go b/migrator/migrator_it_test.go
index e4a839a55..82e3903c2 100644
--- a/migrator/migrator_it_test.go
+++ b/migrator/migrator_it_test.go
@@ -30,6 +30,10 @@ import (
 )
 
 var (
+	path_in         string
+	path_out        string
+	cfg_in          *config.CGRConfig
+	cfg_out         *config.CGRConfig
 	Move            = "move"
 	dbtype          string
 	mig             *Migrator
@@ -46,40 +50,82 @@ var sTestsITMigrator = []func(t *testing.T){
 	testMigratorActions,
 	testMigratorSharedGroups,
 	testMigratorStats,
+	testFlush,
+	testMigratorAlias,
+	//FIXME testMigratorReverseAlias,
+	testMigratorCdrStats,
+	testMigratorDerivedChargers,
+	testMigratorDestinations,
+	testMigratorReverseDestinations,
+	testMigratorLCR,
+	testMigratorRatingPlan,
+	testMigratorRatingProfile,
+	testMigratorRQF,
+	testMigratorResource,
+	testMigratorSubscribers,
+	testMigratorTimings,
+	testMigratorThreshold,
+	//TPS
 	testMigratorTPRatingProfile,
 	testMigratorTPSuppliers,
+	testMigratorTPActions,
+	testMigratorTPAccountActions,
+	testMigratorTpActionTriggers,
+	testMigratorTpActionPlans,
+	testMigratorTpUsers,
+	testMigratorTpTimings,
+	testMigratorTpThreshold,
+	testMigratorTpStats,
+	testMigratorTpSharedGroups,
+	testMigratorTpResources,
+	testMigratorTpRatingProfiles,
+	testMigratorTpRatingPlans,
+	testMigratorTpRates,
+	testMigratorTpLCRRules,
+	testMigratorTpFilter,
+	testMigratorTpDestination,
+	testMigratorTpDestinationRate,
+	testMigratorTpDerivedChargers,
+	testMigratorTpCdrStats,
+	testMigratorTpAliases,
 	testFlush,
 }
 
 func TestMigratorITPostgresConnect(t *testing.T) {
-	cdrsPostgresCfgPath := path.Join(*dataDir, "conf", "samples", "tutpostgres")
-	postgresITCfg, err := config.NewCGRConfigFromFolder(cdrsPostgresCfgPath)
+	path_in := path.Join(*dataDir, "conf", "samples", "tutpostgres")
+	cfg_in, err := config.NewCGRConfigFromFolder(path_in)
 	if err != nil {
 		t.Fatal(err)
 	}
-	dataDB, err := engine.ConfigureDataStorage(postgresITCfg.DataDbType, postgresITCfg.DataDbHost, postgresITCfg.DataDbPort, postgresITCfg.DataDbName, postgresITCfg.DataDbUser, postgresITCfg.DataDbPass, postgresITCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
+	dataDB, err := engine.ConfigureDataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName, cfg_in.DataDbUser,
+		cfg_in.DataDbPass, cfg_in.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	dataDB2, err := engine.ConfigureDataStorage(postgresITCfg.DataDbType, postgresITCfg.DataDbHost, postgresITCfg.DataDbPort, postgresITCfg.DataDbName, postgresITCfg.DataDbUser, postgresITCfg.DataDbPass, postgresITCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
+	dataDB2, err := engine.ConfigureDataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName, cfg_in.DataDbUser,
+		cfg_in.DataDbPass, cfg_in.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldDataDB, err := ConfigureV1DataStorage(postgresITCfg.DataDbType, postgresITCfg.DataDbHost, postgresITCfg.DataDbPort, postgresITCfg.DataDbName, postgresITCfg.DataDbUser, postgresITCfg.DataDbPass, postgresITCfg.DBDataEncoding)
+	oldDataDB, err := ConfigureV1DataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName, cfg_in.DataDbUser,
+		cfg_in.DataDbPass, cfg_in.DBDataEncoding)
 	if err != nil {
 		log.Fatal(err)
 	}
-	storDB, err := engine.ConfigureStorStorage(postgresITCfg.StorDBType, postgresITCfg.StorDBHost, postgresITCfg.StorDBPort, postgresITCfg.StorDBName, postgresITCfg.StorDBUser, postgresITCfg.StorDBPass, postgresITCfg.DBDataEncoding,
+	storDB, err := engine.ConfigureStorStorage(cfg_in.StorDBType, cfg_in.StorDBHost, cfg_in.StorDBPort, cfg_in.StorDBName,
+		cfg_in.StorDBUser, cfg_in.StorDBPass, cfg_in.DBDataEncoding,
 		config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldstorDB, err := engine.ConfigureStorStorage(postgresITCfg.StorDBType, postgresITCfg.StorDBHost, postgresITCfg.StorDBPort, postgresITCfg.StorDBName, postgresITCfg.StorDBUser, postgresITCfg.StorDBPass, postgresITCfg.DBDataEncoding,
+	oldstorDB, err := engine.ConfigureStorStorage(cfg_in.StorDBType, cfg_in.StorDBHost, cfg_in.StorDBPort, cfg_in.StorDBName,
+		cfg_in.StorDBUser, cfg_in.StorDBPass, cfg_in.DBDataEncoding,
 		config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
 	if err != nil {
 		log.Fatal(err)
 	}
-	mig, err = NewMigrator(dataDB, dataDB2, postgresITCfg.DataDbType, postgresITCfg.DBDataEncoding, storDB, postgresITCfg.StorDBType, oldDataDB, postgresITCfg.DataDbType, postgresITCfg.DBDataEncoding, oldstorDB, postgresITCfg.StorDBType, false, true, true, false, false)
+	mig, err = NewMigrator(dataDB, dataDB2, cfg_in.DataDbType, cfg_in.DBDataEncoding, storDB, cfg_in.StorDBType, oldDataDB,
+		cfg_in.DataDbType, cfg_in.DBDataEncoding, oldstorDB, cfg_in.StorDBType, false, true, true, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -94,34 +140,40 @@ func TestMigratorITPostgres(t *testing.T) {
 }
 
 func TestMigratorITRedisConnect(t *testing.T) {
-	cdrsMysqlCfgPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
-	mysqlITCfg, err := config.NewCGRConfigFromFolder(cdrsMysqlCfgPath)
+	path_in := path.Join(*dataDir, "conf", "samples", "tutmysql")
+	cfg_in, err := config.NewCGRConfigFromFolder(path_in)
 	if err != nil {
 		t.Fatal(err)
 	}
-	dataDB, err := engine.ConfigureDataStorage(mysqlITCfg.DataDbType, mysqlITCfg.DataDbHost, mysqlITCfg.DataDbPort, mysqlITCfg.DataDbName, mysqlITCfg.DataDbUser, mysqlITCfg.DataDbPass, mysqlITCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
+	dataDB, err := engine.ConfigureDataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName,
+		cfg_in.DataDbUser, cfg_in.DataDbPass, cfg_in.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	dataDB2, err := engine.ConfigureDataStorage(mysqlITCfg.DataDbType, mysqlITCfg.DataDbHost, mysqlITCfg.DataDbPort, mysqlITCfg.DataDbName, mysqlITCfg.DataDbUser, mysqlITCfg.DataDbPass, mysqlITCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
+	dataDB2, err := engine.ConfigureDataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName,
+		cfg_in.DataDbUser, cfg_in.DataDbPass, cfg_in.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldDataDB, err := ConfigureV1DataStorage(mysqlITCfg.DataDbType, mysqlITCfg.DataDbHost, mysqlITCfg.DataDbPort, mysqlITCfg.DataDbName, mysqlITCfg.DataDbUser, mysqlITCfg.DataDbPass, mysqlITCfg.DBDataEncoding)
+	oldDataDB, err := ConfigureV1DataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName,
+		cfg_in.DataDbUser, cfg_in.DataDbPass, cfg_in.DBDataEncoding)
 	if err != nil {
 		log.Fatal(err)
 	}
-	storDB, err := engine.ConfigureStorStorage(mysqlITCfg.StorDBType, mysqlITCfg.StorDBHost, mysqlITCfg.StorDBPort, mysqlITCfg.StorDBName, mysqlITCfg.StorDBUser, mysqlITCfg.StorDBPass, mysqlITCfg.DBDataEncoding,
+	storDB, err := engine.ConfigureStorStorage(cfg_in.StorDBType, cfg_in.StorDBHost, cfg_in.StorDBPort, cfg_in.StorDBName,
+		cfg_in.StorDBUser, cfg_in.StorDBPass, cfg_in.DBDataEncoding,
 		config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldstorDB, err := engine.ConfigureStorStorage(mysqlITCfg.StorDBType, mysqlITCfg.StorDBHost, mysqlITCfg.StorDBPort, mysqlITCfg.StorDBName, mysqlITCfg.StorDBUser, mysqlITCfg.StorDBPass, mysqlITCfg.DBDataEncoding,
+	oldstorDB, err := engine.ConfigureStorStorage(cfg_in.StorDBType, cfg_in.StorDBHost, cfg_in.StorDBPort, cfg_in.StorDBName,
+		cfg_in.StorDBUser, cfg_in.StorDBPass, cfg_in.DBDataEncoding,
 		config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
 	if err != nil {
 		log.Fatal(err)
 	}
-	mig, err = NewMigrator(dataDB, dataDB2, mysqlITCfg.DataDbType, mysqlITCfg.DBDataEncoding, storDB, mysqlITCfg.StorDBType, oldDataDB, mysqlITCfg.DataDbType, mysqlITCfg.DBDataEncoding, oldstorDB, mysqlITCfg.StorDBType, false, true, true, false, false)
+	mig, err = NewMigrator(dataDB, dataDB2, cfg_in.DataDbType, cfg_in.DBDataEncoding, storDB, cfg_in.StorDBType, oldDataDB,
+		cfg_in.DataDbType, cfg_in.DBDataEncoding, oldstorDB, cfg_in.StorDBType, false, true, true, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -136,34 +188,40 @@ func TestMigratorITRedis(t *testing.T) {
 }
 
 func TestMigratorITMongoConnect(t *testing.T) {
-	cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
-	mgoITCfg, err := config.NewCGRConfigFromFolder(cdrsMongoCfgPath)
+	path_in := path.Join(*dataDir, "conf", "samples", "tutmongo")
+	cfg_in, err := config.NewCGRConfigFromFolder(path_in)
 	if err != nil {
 		t.Fatal(err)
 	}
-	dataDB, err := engine.ConfigureDataStorage(mgoITCfg.DataDbType, mgoITCfg.DataDbHost, mgoITCfg.DataDbPort, mgoITCfg.DataDbName, mgoITCfg.DataDbUser, mgoITCfg.DataDbPass, mgoITCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
+	dataDB, err := engine.ConfigureDataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName,
+		cfg_in.DataDbUser, cfg_in.DataDbPass, cfg_in.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	dataDB2, err := engine.ConfigureDataStorage(mgoITCfg.DataDbType, mgoITCfg.DataDbHost, mgoITCfg.DataDbPort, mgoITCfg.DataDbName, mgoITCfg.DataDbUser, mgoITCfg.DataDbPass, mgoITCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
+	dataDB2, err := engine.ConfigureDataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName,
+		cfg_in.DataDbUser, cfg_in.DataDbPass, cfg_in.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldDataDB, err := ConfigureV1DataStorage(mgoITCfg.DataDbType, mgoITCfg.DataDbHost, mgoITCfg.DataDbPort, mgoITCfg.DataDbName, mgoITCfg.DataDbUser, mgoITCfg.DataDbPass, mgoITCfg.DBDataEncoding)
+	oldDataDB, err := ConfigureV1DataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName,
+		cfg_in.DataDbUser, cfg_in.DataDbPass, cfg_in.DBDataEncoding)
 	if err != nil {
 		log.Fatal(err)
 	}
-	storDB, err := engine.ConfigureStorStorage(mgoITCfg.StorDBType, mgoITCfg.StorDBHost, mgoITCfg.StorDBPort, mgoITCfg.StorDBName, mgoITCfg.StorDBUser, mgoITCfg.StorDBPass, mgoITCfg.DBDataEncoding,
+	storDB, err := engine.ConfigureStorStorage(cfg_in.StorDBType, cfg_in.StorDBHost, cfg_in.StorDBPort, cfg_in.StorDBName,
+		cfg_in.StorDBUser, cfg_in.StorDBPass, cfg_in.DBDataEncoding,
 		config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldstorDB, err := engine.ConfigureStorStorage(mgoITCfg.StorDBType, mgoITCfg.StorDBHost, mgoITCfg.StorDBPort, mgoITCfg.StorDBName, mgoITCfg.StorDBUser, mgoITCfg.StorDBPass, mgoITCfg.DBDataEncoding,
+	oldstorDB, err := engine.ConfigureStorStorage(cfg_in.StorDBType, cfg_in.StorDBHost, cfg_in.StorDBPort, cfg_in.StorDBName,
+		cfg_in.StorDBUser, cfg_in.StorDBPass, cfg_in.DBDataEncoding,
 		config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
 	if err != nil {
 		log.Fatal(err)
 	}
-	mig, err = NewMigrator(dataDB, dataDB2, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, storDB, mgoITCfg.StorDBType, oldDataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, oldstorDB, mgoITCfg.StorDBType, false, true, true, false, false)
+	mig, err = NewMigrator(dataDB, dataDB2, cfg_in.DataDbType, cfg_in.DBDataEncoding, storDB, cfg_in.StorDBType, oldDataDB,
+		cfg_in.DataDbType, cfg_in.DBDataEncoding, oldstorDB, cfg_in.StorDBType, false, true, true, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -178,39 +236,45 @@ func TestMigratorITMongo(t *testing.T) {
 }
 
 func TestMigratorITMoveConnect(t *testing.T) {
-	cdrsMongoCfgPath := path.Join(*dataDir, "conf", "samples", "tutmongo")
-	mgoITCfg, err := config.NewCGRConfigFromFolder(cdrsMongoCfgPath)
+	path_in := path.Join(*dataDir, "conf", "samples", "tutmongo")
+	cfg_in, err := config.NewCGRConfigFromFolder(path_in)
 	if err != nil {
 		t.Fatal(err)
 	}
-	cdrsMysqlCfgPath := path.Join(*dataDir, "conf", "samples", "tutmysql")
-	mysqlITCfg, err := config.NewCGRConfigFromFolder(cdrsMysqlCfgPath)
+	path_out := path.Join(*dataDir, "conf", "samples", "tutmysql")
+	cfg_out, err := config.NewCGRConfigFromFolder(path_out)
 	if err != nil {
 		t.Fatal(err)
 	}
-	dataDB, err := engine.ConfigureDataStorage(mgoITCfg.DataDbType, mgoITCfg.DataDbHost, mgoITCfg.DataDbPort, mgoITCfg.DataDbName, mgoITCfg.DataDbUser, mgoITCfg.DataDbPass, mgoITCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
+	dataDB, err := engine.ConfigureDataStorage(cfg_in.DataDbType, cfg_in.DataDbHost, cfg_in.DataDbPort, cfg_in.DataDbName,
+		cfg_in.DataDbUser, cfg_in.DataDbPass, cfg_in.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	dataDB2, err := engine.ConfigureDataStorage(mysqlITCfg.DataDbType, mysqlITCfg.DataDbHost, mysqlITCfg.DataDbPort, mysqlITCfg.DataDbName, mysqlITCfg.DataDbUser, mysqlITCfg.DataDbPass, mysqlITCfg.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
+	dataDB2, err := engine.ConfigureDataStorage(cfg_out.DataDbType, cfg_out.DataDbHost, cfg_out.DataDbPort, cfg_out.DataDbName,
+		cfg_out.DataDbUser, cfg_out.DataDbPass, cfg_out.DBDataEncoding, config.CgrConfig().CacheCfg(), *loadHistorySize)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldDataDB, err := ConfigureV1DataStorage(mysqlITCfg.DataDbType, mysqlITCfg.DataDbHost, mysqlITCfg.DataDbPort, mysqlITCfg.DataDbName, mysqlITCfg.DataDbUser, mysqlITCfg.DataDbPass, mysqlITCfg.DBDataEncoding)
+	oldDataDB, err := ConfigureV1DataStorage(cfg_out.DataDbType, cfg_out.DataDbHost, cfg_out.DataDbPort, cfg_out.DataDbName,
+		cfg_out.DataDbUser, cfg_out.DataDbPass, cfg_out.DBDataEncoding)
 	if err != nil {
 		log.Fatal(err)
 	}
-	storDB, err := engine.ConfigureStorStorage(mgoITCfg.StorDBType, mgoITCfg.StorDBHost, mgoITCfg.StorDBPort, mgoITCfg.StorDBName, mgoITCfg.StorDBUser, mgoITCfg.StorDBPass, mgoITCfg.DBDataEncoding,
+	storDB, err := engine.ConfigureStorStorage(cfg_in.StorDBType, cfg_in.StorDBHost, cfg_in.StorDBPort, cfg_in.StorDBName,
+		cfg_in.StorDBUser, cfg_in.StorDBPass, cfg_in.DBDataEncoding,
 		config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
 	if err != nil {
 		log.Fatal(err)
 	}
-	oldstorDB, err := engine.ConfigureStorStorage(mysqlITCfg.StorDBType, mysqlITCfg.StorDBHost, mysqlITCfg.StorDBPort, mysqlITCfg.StorDBName, mysqlITCfg.StorDBUser, mysqlITCfg.StorDBPass, mysqlITCfg.DBDataEncoding,
+	oldstorDB, err := engine.ConfigureStorStorage(cfg_out.StorDBType, cfg_out.StorDBHost, cfg_out.StorDBPort, cfg_out.StorDBName,
+		cfg_out.StorDBUser, cfg_out.StorDBPass, cfg_out.DBDataEncoding,
 		config.CgrConfig().StorDBMaxOpenConns, config.CgrConfig().StorDBMaxIdleConns, config.CgrConfig().StorDBConnMaxLifetime, config.CgrConfig().StorDBCDRSIndexes)
 	if err != nil {
 		log.Fatal(err)
 	}
-	mig, err = NewMigrator(dataDB2, dataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, storDB, mgoITCfg.StorDBType, oldDataDB, mgoITCfg.DataDbType, mgoITCfg.DBDataEncoding, oldstorDB, mgoITCfg.StorDBType, false, false, false, false, false)
+	mig, err = NewMigrator(dataDB2, dataDB, cfg_in.DataDbType, cfg_in.DBDataEncoding, storDB, cfg_in.StorDBType, oldDataDB,
+		cfg_in.DataDbType, cfg_in.DBDataEncoding, oldstorDB, cfg_in.StorDBType, false, false, false, false, false)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -229,7 +293,16 @@ func testFlush(t *testing.T) {
 	if err := engine.SetDBVersions(mig.dmOut.DataDB()); err != nil {
 		t.Error("Error  ", err.Error())
 	}
-
+	if path_out != "" {
+		if err := mig.InStorDB().Flush(path.Join(cfg_in.DataFolderPath, "storage", cfg_in.StorDBType)); err != nil {
+			t.Error(err)
+		}
+	}
+	if path_out != "" {
+		if err := mig.OutStorDB().Flush(path.Join(cfg_out.DataFolderPath, "storage", cfg_out.StorDBType)); err != nil {
+			t.Error(err)
+		}
+	}
 }
 
 func testMigratorAccounts(t *testing.T) {
@@ -248,20 +321,20 @@ func testMigratorAccounts(t *testing.T) {
 	case dbtype == utils.REDIS:
 		err := mig.oldDataDB.setV1Account(v1Acc)
 		if err != nil {
-			t.Error("Error when setting v1 acc ", err.Error())
+			t.Error("Error when setting v1 Accounts ", err.Error())
 		}
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 1, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for Accounts ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaAccounts})
 		if err != nil {
-			t.Error("Error when migrating accounts ", err.Error())
+			t.Error("Error when migrating Accounts ", err.Error())
 		}
 		result, err := mig.dmOut.DataDB().GetAccount(testAccount.ID)
 		if err != nil {
-			t.Error("Error when getting account ", err.Error())
+			t.Error("Error when getting Accounts ", err.Error())
 		}
 		if !reflect.DeepEqual(testAccount.BalanceMap["*voice"][0], result.BalanceMap["*voice"][0]) {
 			t.Errorf("Expecting: %+v, received: %+v", testAccount.BalanceMap["*voice"][0], result.BalanceMap["*voice"][0])
@@ -276,15 +349,15 @@ func testMigratorAccounts(t *testing.T) {
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 1, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for Accounts ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaAccounts})
 		if err != nil {
-			t.Error("Error when migrating accounts ", err.Error())
+			t.Error("Error when migrating Accounts ", err.Error())
 		}
 		result, err := mig.dmOut.DataDB().GetAccount(testAccount.ID)
 		if err != nil {
-			t.Error("Error when getting account ", err.Error())
+			t.Error("Error when getting Accounts ", err.Error())
 		}
 		if !reflect.DeepEqual(testAccount, result) {
 			t.Errorf("Expecting: %+v, received: %+v", testAccount, result)
@@ -296,11 +369,11 @@ func testMigratorAccounts(t *testing.T) {
 		currentVersion := engine.CurrentDataDBVersions()
 		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for Accounts ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaAccounts})
 		if err != nil {
-			t.Error("Error when migrating accounts ", err.Error())
+			t.Error("Error when migrating Accounts ", err.Error())
 		}
 		result, err := mig.dmOut.DataDB().GetAccount(testAccount.ID)
 		if err != nil {
@@ -324,7 +397,7 @@ func testMigratorActionPlans(t *testing.T) {
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 1, utils.SharedGroups: 2}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for ActionPlan ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaActionPlans})
 		if err != nil {
@@ -349,7 +422,7 @@ func testMigratorActionPlans(t *testing.T) {
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 1, utils.SharedGroups: 2}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for ActionPlan ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaActionPlans})
 		if err != nil {
@@ -373,7 +446,7 @@ func testMigratorActionPlans(t *testing.T) {
 		currentVersion := engine.CurrentDataDBVersions()
 		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for ActionPlan ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaActionPlans})
 		if err != nil {
@@ -434,7 +507,7 @@ func testMigratorActionTriggers(t *testing.T) {
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 1, utils.ActionPlans: 2, utils.SharedGroups: 2}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for ActionTriggers ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaActionTriggers})
 		if err != nil {
@@ -520,11 +593,11 @@ func testMigratorActionTriggers(t *testing.T) {
 		currentVersion := engine.CurrentDataDBVersions()
 		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for ActionTriggers ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaActionTriggers})
 		if err != nil {
-			t.Error("Error when migrating ActionPlans ", err.Error())
+			t.Error("Error when migrating ActionTriggers ", err.Error())
 		}
 		result, err := mig.dmOut.GetActionTriggers(atrs[0].ID, true, utils.NonTransactional)
 		if err != nil {
@@ -597,8 +670,45 @@ func testMigratorActionTriggers(t *testing.T) {
 }
 
 func testMigratorActions(t *testing.T) {
-	v1act := &v1Actions{&v1Action{Id: "test", ActionType: "", BalanceType: "", Direction: "INBOUND", ExtraParameters: "", ExpirationString: "", Balance: &v1Balance{Timings: []*engine.RITiming{&engine.RITiming{Years: utils.Years{}, Months: utils.Months{}, MonthDays: utils.MonthDays{}, WeekDays: utils.WeekDays{}}}}}}
-	act := &engine.Actions{&engine.Action{Id: "test", ActionType: "", ExtraParameters: "", ExpirationString: "", Weight: 0.00, Balance: &engine.BalanceFilter{Timings: []*engine.RITiming{&engine.RITiming{Years: utils.Years{}, Months: utils.Months{}, MonthDays: utils.MonthDays{}, WeekDays: utils.WeekDays{}}}}}}
+	v1act := &v1Actions{
+		&v1Action{
+			Id:               "test",
+			ActionType:       "",
+			BalanceType:      "",
+			Direction:        "INBOUND",
+			ExtraParameters:  "",
+			ExpirationString: "",
+			Balance: &v1Balance{
+				Timings: []*engine.RITiming{
+					&engine.RITiming{
+						Years:     utils.Years{},
+						Months:    utils.Months{},
+						MonthDays: utils.MonthDays{},
+						WeekDays:  utils.WeekDays{},
+					},
+				},
+			},
+		},
+	}
+	act := &engine.Actions{
+		&engine.Action{
+			Id:               "test",
+			ActionType:       "",
+			ExtraParameters:  "",
+			ExpirationString: "",
+			Weight:           0.00,
+			Balance: &engine.BalanceFilter{
+				Timings: []*engine.RITiming{
+					&engine.RITiming{
+						Years:     utils.Years{},
+						Months:    utils.Months{},
+						MonthDays: utils.MonthDays{},
+						WeekDays:  utils.WeekDays{},
+					},
+				},
+			},
+		},
+	}
 	switch {
 	case dbtype == utils.REDIS:
 		err := mig.oldDataDB.setV1Actions(v1act)
@@ -608,7 +718,7 @@ func testMigratorActions(t *testing.T) {
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 1, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for Actions ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaActions})
 		if err != nil {
@@ -630,7 +740,7 @@ func testMigratorActions(t *testing.T) {
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 1, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 2}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for Actions ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaActions})
 		if err != nil {
@@ -650,15 +760,15 @@ func testMigratorActions(t *testing.T) {
 		currentVersion := engine.CurrentDataDBVersions()
 		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for Actions ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaActions})
 		if err != nil {
-			t.Error("Error when migrating ActionPlans ", err.Error())
+			t.Error("Error when migrating Actions ", err.Error())
 		}
 		result, err := mig.dmOut.GetActions((*v1act)[0].Id, true, utils.NonTransactional)
 		if err != nil {
-			t.Error("Error when getting ActionPlan ", err.Error())
+			t.Error("Error when getting Actions ", err.Error())
 		}
 		if !reflect.DeepEqual(*act, result) {
 			t.Errorf("Expecting: %+v, received: %+v", *act, result)
@@ -690,7 +800,7 @@ func testMigratorSharedGroups(t *testing.T) {
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 1}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for SharedGroup ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaSharedGroups})
 		if err != nil {
@@ -711,7 +821,7 @@ func testMigratorSharedGroups(t *testing.T) {
 		currentVersion := engine.Versions{utils.StatS: 2, utils.Thresholds: 2, utils.Accounts: 2, utils.Actions: 2, utils.ActionTriggers: 2, utils.ActionPlans: 2, utils.SharedGroups: 1}
 		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for SharedGroup ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaSharedGroups})
 		if err != nil {
@@ -731,7 +841,7 @@ func testMigratorSharedGroups(t *testing.T) {
 		currentVersion := engine.CurrentDataDBVersions()
 		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for SharedGroup ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaSharedGroups})
 		if err != nil {
@@ -1000,36 +1110,752 @@ func testMigratorStats(t *testing.T) {
 	}
 }
 
-func testMigratorTPRatingProfile(t *testing.T) {
-	tpRatingProfile := &utils.TPRatingProfile{
-		TPid:      "TPRProf1",
-		LoadId:    "RPrf",
+func testMigratorThreshold(t *testing.T) {
+	tim := time.Date(2012, time.February, 27, 23, 59, 59, 0, time.UTC).Local()
+	tenant := config.CgrConfig().DefaultTenant
+	var filters []*engine.RequestFilter
+	threshold := &v2ActionTrigger{
+		ID:             "test2",              // original csv tag
+		UniqueID:       "testUUID",           // individual id
+		ThresholdType:  "*min_event_counter", //*min_event_counter, *max_event_counter, *min_balance_counter, *max_balance_counter, *min_balance, *max_balance, *balance_expired
+		ThresholdValue: 5.32,
+		Recurrent:      false,                          // reset excuted flag each run
+		MinSleep:       time.Duration(5) * time.Second, // Minimum duration between two executions in case of recurrent triggers
+		ExpirationDate: time.Now(),
+		ActivationDate: time.Now(),
+		Balance: &engine.BalanceFilter{
+			ID:             utils.StringPointer("TESTZ"),
+			Timings:        []*engine.RITiming{},
+			ExpirationDate: utils.TimePointer(tim),
+			Type:           utils.StringPointer(utils.MONETARY),
+			Directions:     utils.StringMapPointer(utils.NewStringMap(utils.OUT)),
+		},
+		Weight:            0,
+		ActionsID:         "Action1",
+		MinQueuedItems:    10, // Trigger actions only if this number is hit (stats only)
+		Executed:          false,
+		LastExecutionTime: time.Now(),
+	}
+	x, err := engine.NewRequestFilter(engine.MetaRSRFields, "Directions", threshold.Balance.Directions.Slice())
+	if err != nil {
+		t.Error("Error when creating new NewRequestFilter", err.Error())
+	}
+	filters = append(filters, x)
+
+	filter := &engine.Filter{Tenant: config.CgrConfig().DefaultTenant, ID: *threshold.Balance.ID, RequestFilters: filters}
+
+	thp := &engine.ThresholdProfile{
+		ID:                 threshold.ID,
+		Tenant:             config.CgrConfig().DefaultTenant,
+		Blocker:            false,
+		Weight:             threshold.Weight,
+		ActivationInterval: &utils.ActivationInterval{threshold.ExpirationDate, threshold.ActivationDate},
+		MinSleep:           threshold.MinSleep,
+	}
+	th := &engine.Threshold{
+		Tenant: config.CgrConfig().DefaultTenant,
+		ID:     threshold.ID,
+	}
+
+	switch {
+	case dbtype == utils.REDIS:
+		if err := mig.dmIN.SetFilter(filter); err != nil {
+			t.Error("Error when setting Filter ", err.Error())
+		}
+		if err := mig.dmIN.SetThresholdProfile(thp); err != nil {
+			t.Error("Error when setting threshold ", err.Error())
+		}
+		if err := mig.dmIN.SetThreshold(th); err != nil {
+			t.Error("Error when setting threshold ", err.Error())
+		}
+		err := mig.oldDataDB.setV2ActionTrigger(threshold)
+		if err != nil {
+			t.Error("Error when setting threshold ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		currentVersion[utils.Thresholds] = 1
+		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for threshold ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaThresholds})
+		if err != nil {
+			t.Error("Error when migrating threshold ", err.Error())
+		}
+		result, err := mig.dmOut.GetThreshold("cgrates.org", threshold.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting threshold ", err.Error())
+		}
+		if !reflect.DeepEqual(th, result) {
+			t.Errorf("Expecting: %+v, received: %+v", th, result)
+		}
+		thpr, err := mig.dmOut.GetThresholdProfile(thp.Tenant, thp.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting thresholdProfile ", err.Error())
+		}
+		if !reflect.DeepEqual(thp.ID, thpr.ID) {
+			t.Errorf("Expecting: %+v, received: %+v", thp.ID, thpr.ID)
+		}
+	case dbtype == utils.MONGO:
+		if err := mig.dmIN.SetFilter(filter); err != nil {
+			t.Error("Error when setting Filter ", err.Error())
+		}
+		if err := mig.dmIN.SetThresholdProfile(thp); err != nil {
+			t.Error("Error when setting Threshold ", err.Error())
+		}
+		if err := mig.dmIN.SetThreshold(th); err != nil {
+			t.Error("Error when setting Threshold ", err.Error())
+		}
+		err := mig.oldDataDB.setV2ActionTrigger(threshold)
+		if err != nil {
+			t.Error("Error when setting Threshold ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		currentVersion[utils.Thresholds] = 1
+		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Threshold ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaThresholds})
+		if err != nil {
+			t.Error("Error when migrating Threshold ", err.Error())
+		}
+		result, err := mig.dmOut.GetThreshold("cgrates.org", threshold.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting Threshold ", err.Error())
+		}
+		if !reflect.DeepEqual(th, result) {
+			t.Errorf("Expecting: %+v, received: %+v", th, result)
+		}
+		thpr, err := mig.dmOut.GetThresholdProfile(thp.Tenant, thp.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting thresholdProfile ", err.Error())
+		}
+		if !reflect.DeepEqual(thp.ID, thpr.ID) {
+			t.Errorf("Expecting: %+v, received: %+v", thp.ID, thpr.ID)
+		}
+	case dbtype == Move:
+		if err := mig.dmIN.SetFilter(filter); err != nil {
+			t.Error("Error when setting Filter ", err.Error())
+		}
+		if err := mig.dmIN.SetThresholdProfile(thp); err != nil {
+			t.Error("Error when setting Threshold ", err.Error())
+		}
+		if err := mig.dmIN.SetThreshold(th); err != nil {
+			t.Error("Error when setting Threshold ", err.Error())
+		}
+		err := mig.oldDataDB.setV2ActionTrigger(threshold)
+		if err != nil {
+			t.Error("Error when setting Threshold ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err = mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Threshold ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaThresholds})
+		if err != nil {
+			t.Error("Error when migrating Threshold ", err.Error())
+		}
+		result, err := mig.dmOut.GetThreshold(tenant, threshold.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting Threshold ", err.Error())
+		}
+		if !reflect.DeepEqual(th, result) {
+			t.Errorf("Expecting: %+v, received: %+v", th, result)
+		}
+		thpr, err := mig.dmOut.GetThresholdProfile(thp.Tenant, thp.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting ThresholdProfile ", err.Error())
+		}
+		if !reflect.DeepEqual(thp.ID, thpr.ID) {
+			t.Errorf("Expecting: %+v, received: %+v", thp.ID, thpr.ID)
+		}
+	}
+}
+
+func testMigratorAlias(t *testing.T) {
+	alias := &engine.Alias{
 		Direction: "*out",
-		Tenant:    "Tenant1",
-		Category:  "Category",
-		Subject:   "Subject",
-		RatingPlanActivations: []*utils.TPRatingActivation{
-			&utils.TPRatingActivation{
-				ActivationTime:   "2014-07-29T15:00:00Z",
-				RatingPlanId:     "PlanOne",
-				FallbackSubjects: "FallBack",
-				CdrStatQueueIds:  "RandomId",
+		Tenant:    "cgrates.org",
+		Category:  "call",
+		Account:   "dan",
+		Subject:   "dan",
+		Context:   "*rating",
+		Values: engine.AliasValues{
+			&engine.AliasValue{
+				DestinationId: "EU_LANDLINE",
+				Pairs: engine.AliasPairs{
+					"Subject": map[string]string{
+						"dan": "dan1",
+						"rif": "rif1",
+					},
+					"Cli": map[string]string{
+						"0723": "0724",
+					},
+				},
+				Weight: 10,
 			},
-			&utils.TPRatingActivation{
-				ActivationTime:   "2015-07-29T10:00:00Z",
-				RatingPlanId:     "PlanTwo",
-				FallbackSubjects: "FallOut",
-				CdrStatQueueIds:  "RandomIdTwo",
+
+			&engine.AliasValue{
+				DestinationId: "GLOBAL1",
+				Pairs:         engine.AliasPairs{"Subject": map[string]string{"dan": "dan2"}},
+				Weight:        20,
 			},
 		},
 	}
 	switch dbtype {
 	case Move:
-		if err := mig.InStorDB().SetTPRatingProfiles([]*utils.TPRatingProfile{tpRatingProfile}); err != nil {
-			t.Error("Error when setting Stats ", err.Error())
+		if err := mig.dmIN.DataDB().SetAlias(alias, utils.NonTransactional); err != nil {
+			t.Error("Error when setting Alias ", err.Error())
 		}
 		currentVersion := engine.CurrentDataDBVersions()
 		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Alias ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaAlias})
+		if err != nil {
+			t.Error("Error when migrating Alias ", err.Error())
+		}
+		result, err := mig.dmOut.DataDB().GetAlias(alias.GetId(), true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting Alias ", err.Error())
+		}
+		if !reflect.DeepEqual(alias, result) {
+			t.Errorf("Expecting: %+v, received: %+v", alias, result)
+		}
+	}
+}
+
+//WILL UPDATE AFTER RELEASE OF NEW ALIAS
+//FIXME
+// func testMigratorReverseAlias(t *testing.T) {
+// 	alias := &engine.Alias{
+// 		Direction: "*out",
+// 		Tenant:    "cgrates.org",
+// 		Category:  "call",
+// 		Account:   "dan",
+// 		Subject:   "dan",
+// 		Context:   "*rating",
+// 		Values: engine.AliasValues{
+// 			&engine.AliasValue{
+// 				DestinationId: "EU_LANDLINE",
+// 				Pairs: engine.AliasPairs{
+// 					"Subject": map[string]string{
+// 						"dan": "dan1",
+// 						"rif": "rif1",
+// 					},
+// 					"Cli": map[string]string{
+// 						"0723": "0724",
+// 					},
+// 				},
+// 				Weight: 10,
+// 			},
+
+// 			&engine.AliasValue{
+// 				DestinationId: "GLOBAL1",
+// 				Pairs:         engine.AliasPairs{"Subject": map[string]string{"dan": "dan2"}},
+// 				Weight:        20,
+// 			},
+// 		},
+// 	}
+// 	switch dbtype {
+// 	case Move:
+// 		if err := mig.dmIN.DataDB().SetReverseAlias(alias, utils.NonTransactional); err != nil {
+// 			t.Error("Error when setting ReverseAlias ", err.Error())
+// 		}
+// 		currentVersion := engine.CurrentDataDBVersions()
+// 		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+// 		if err != nil {
+// 			t.Error("Error when setting version for ReverseAlias ", err.Error())
+// 		}
+// 		err, _ = mig.Migrate([]string{utils.MetaReverseAlias})
+// 		if err != nil {
+// 			t.Error("Error when migrating ReverseAlias ", err.Error())
+// 		}
+// 		result, err := mig.dmOut.DataDB().GetReverseAlias(alias.GetId(), true, utils.NonTransactional)
+// 		if err != nil {
+// 			t.Error("Error when getting ReverseAlias ", err.Error())
+// 		}
+// 		if !reflect.DeepEqual(alias, result) {
+// 			t.Errorf("Expecting: %+v, received: %+v", alias, result)
+// 		}
+// 	}
+// }
+
+func testMigratorCdrStats(t *testing.T) {
+	cdrs := &engine.CdrStats{
+		Id:              "",
+		QueueLength:     10,                             // Number of items in the stats buffer
+		TimeWindow:      time.Duration(1) * time.Second, // Will only keep the CDRs who's call setup time is not older than time.Now()-TimeWindow
+		SaveInterval:    time.Duration(1) * time.Second,
+		Metrics:         []string{engine.ASR, engine.PDD, engine.ACD, engine.TCD, engine.ACC, engine.TCC, engine.DDC},
+		SetupInterval:   []time.Time{time.Date(2012, time.February, 27, 23, 59, 59, 0, time.UTC).Local()}, // CDRFieldFilter on SetupInterval, 2 or less items (>= start interval,< stop_interval)
+		TOR:             []string{""},                                                                     // CDRFieldFilter on TORs
+		CdrHost:         []string{""},                                                                     // CDRFieldFilter on CdrHosts
+		CdrSource:       []string{""},                                                                     // CDRFieldFilter on CdrSources
+		ReqType:         []string{""},                                                                     // CDRFieldFilter on RequestTypes
+		Direction:       []string{""},                                                                     // CDRFieldFilter on Directions
+		Tenant:          []string{""},                                                                     // CDRFieldFilter on Tenants
+		Category:        []string{""},                                                                     // CDRFieldFilter on Categories
+		Account:         []string{""},                                                                     // CDRFieldFilter on Accounts
+		Subject:         []string{""},                                                                     // CDRFieldFilter on Subjects
+		DestinationIds:  []string{""},                                                                     // CDRFieldFilter on DestinationPrefixes
+		UsageInterval:   []time.Duration{time.Duration(1) * time.Second},                                  // CDRFieldFilter on UsageInterval, 2 or less items (>= Usage, <Usage)
+		PddInterval:     []time.Duration{time.Duration(1) * time.Second},                                  // CDRFieldFilter on PddInterval, 2 or less items (>= Pdd, <Pdd)
+		Supplier:        []string{},                                                                       // CDRFieldFilter on Suppliers
+		DisconnectCause: []string{},                                                                       // Filter on DisconnectCause
+		MediationRunIds: []string{},                                                                       // CDRFieldFilter on MediationRunIds
+		RatedAccount:    []string{},                                                                       // CDRFieldFilter on RatedAccounts
+		RatedSubject:    []string{},                                                                       // CDRFieldFilter on RatedSubjects
+		CostInterval:    []float64{},                                                                      // CDRFieldFilter on CostInterval, 2 or less items, (>=Cost, <Cost)
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.SetCdrStats(cdrs); err != nil {
+			t.Error("Error when setting CdrStats ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for CdrStats ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaCdrStats})
+		if err != nil {
+			t.Error("Error when migrating CdrStats ", err.Error())
+		}
+		result, err := mig.dmOut.GetCdrStats("")
+		if err != nil {
+			t.Error("Error when getting CdrStats ", err.Error())
+		}
+		if !reflect.DeepEqual(cdrs.Metrics, result.Metrics) {
+			t.Errorf("Expecting: %v, received: %v", cdrs.Metrics, result.Metrics)
+		} else if !reflect.DeepEqual(cdrs.SetupInterval, result.SetupInterval) {
+			t.Errorf("Expecting: %+v, received: %+v", cdrs.SetupInterval, result.SetupInterval)
+		} else if !reflect.DeepEqual(cdrs.PddInterval, result.PddInterval) {
+			t.Errorf("Expecting: %+v, received: %+v", cdrs.PddInterval, result.PddInterval)
+		} else if !reflect.DeepEqual(cdrs.SaveInterval, result.SaveInterval) {
+			t.Errorf("Expecting: %+v, received: %+v", cdrs.SaveInterval, result.SaveInterval)
+		}
+	}
+}
+
+func testMigratorDerivedChargers(t *testing.T) {
+	dcs := &utils.DerivedChargers{
+		DestinationIDs: make(utils.StringMap),
+		Chargers: []*utils.DerivedCharger{
+			&utils.DerivedCharger{
+				RunID: "extra1", RunFilters: "^filteredHeader1/filterValue1/", RequestTypeField: "^prepaid", DirectionField: utils.META_DEFAULT,
+				TenantField: utils.META_DEFAULT, CategoryField: utils.META_DEFAULT, AccountField: "rif", SubjectField: "rif", DestinationField: utils.META_DEFAULT,
+				SetupTimeField: utils.META_DEFAULT, PDDField: utils.META_DEFAULT, AnswerTimeField: utils.META_DEFAULT, UsageField: utils.META_DEFAULT,
+				SupplierField: utils.META_DEFAULT, DisconnectCauseField: utils.META_DEFAULT, CostField: utils.META_DEFAULT, RatedField: utils.META_DEFAULT,
+			},
+		},
+	}
+	keyDCS := utils.ConcatenatedKey("*out", "itsyscom.com", "call", "dan", "dan")
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.DataDB().SetDerivedChargers(keyDCS, dcs, utils.NonTransactional); err != nil {
+			t.Error("Error when setting DerivedChargers ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for DerivedChargers ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaDerivedChargersV})
+		if err != nil {
+			t.Error("Error when migrating DerivedChargers ", err.Error())
+		}
+		result, err := mig.dmOut.GetDerivedChargers(keyDCS, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting DerivedChargers ", err.Error())
+		}
+		if !reflect.DeepEqual(dcs, result) {
+			t.Errorf("Expecting: %v, received: %v", dcs, result)
+		}
+	}
+}
+
+func testMigratorDestinations(t *testing.T) {
+	dst := &engine.Destination{Id: "CRUDDestination2", Prefixes: []string{"+491", "+492", "+493"}}
+
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.DataDB().SetDestination(dst, utils.NonTransactional); err != nil {
+			t.Error("Error when setting Destinations ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Destinations ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaDestinations})
+		if err != nil {
+			t.Error("Error when migrating Destinations ", err.Error())
+		}
+		result, err := mig.dmOut.DataDB().GetDestination(dst.Id, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting Destinations ", err.Error())
+		}
+		if !reflect.DeepEqual(dst, result) {
+			t.Errorf("Expecting: %v, received: %v", dst, result)
+		}
+	}
+}
+
+func testMigratorReverseDestinations(t *testing.T) {
+	dst := &engine.Destination{Id: "CRUDReverseDestination", Prefixes: []string{"+494", "+495", "+496"}}
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.DataDB().SetReverseDestination(dst, utils.NonTransactional); err != nil {
+			t.Error("Error when setting ReverseDestinations ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for ReverseDestinations ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaReverseDestinations})
+		if err != nil {
+			t.Error("Error when migrating ReverseDestinations ", err.Error())
+		}
+		for i, _ := range dst.Prefixes {
+			result, err := mig.dmOut.DataDB().GetReverseDestination(dst.Prefixes[i], true, utils.NonTransactional)
+			if err != nil {
+				t.Error("Error when getting ReverseDestinations ", err.Error())
+			} else if !reflect.DeepEqual([]string{dst.Id}, result) {
+				t.Errorf("Expecting: %v, received: %v", []string{dst.Id}, result)
+			}
+		}
+	}
+}
+
+func testMigratorLCR(t *testing.T) {
+	lcr := &engine.LCR{
+		Tenant:    "cgrates.org",
+		Category:  "call",
+		Direction: "*out",
+		Account:   "testOnStorITCRUDLCR",
+		Subject:   "testOnStorITCRUDLCR",
+		Activations: []*engine.LCRActivation{
+			&engine.LCRActivation{
+				ActivationTime: time.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC).Local(),
+				Entries: []*engine.LCREntry{
+					&engine.LCREntry{
+						DestinationId:  "EU_LANDLINE",
+						RPCategory:     "LCR_STANDARD",
+						Strategy:       "*static",
+						StrategyParams: "ivo;dan;rif",
+						Weight:         10,
+					},
+					&engine.LCREntry{
+						DestinationId:  "*any",
+						RPCategory:     "LCR_STANDARD",
+						Strategy:       "*lowest_cost",
+						StrategyParams: "",
+						Weight:         20,
+					},
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.SetLCR(lcr, utils.NonTransactional); err != nil {
+			t.Error("Error when setting Lcr ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Lcr ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaLCR})
+		if err != nil {
+			t.Error("Error when migrating Lcr ", err.Error())
+		}
+		result, err := mig.dmOut.GetLCR(lcr.GetId(), true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting Lcr ", err.Error())
+		}
+		if !reflect.DeepEqual(lcr, result) {
+			t.Errorf("Expecting: %v, received: %v", lcr, result)
+		}
+	}
+}
+
+func testMigratorRatingPlan(t *testing.T) {
+	rp := &engine.RatingPlan{
+		Id: "CRUDRatingPlan",
+		Timings: map[string]*engine.RITiming{
+			"59a981b9": &engine.RITiming{
+				Years:     utils.Years{},
+				Months:    utils.Months{},
+				MonthDays: utils.MonthDays{},
+				WeekDays:  utils.WeekDays{1, 2, 3, 4, 5},
+				StartTime: "00:00:00",
+			},
+		},
+		Ratings: map[string]*engine.RIRate{
+			"ebefae11": &engine.RIRate{
+				ConnectFee: 0,
+				Rates: []*engine.Rate{
+					&engine.Rate{
+						GroupIntervalStart: 0,
+						Value:              0.2,
+						RateIncrement:      time.Second,
+						RateUnit:           time.Minute,
+					},
+				},
+				RoundingMethod:   utils.ROUNDING_MIDDLE,
+				RoundingDecimals: 4,
+			},
+		},
+		DestinationRates: map[string]engine.RPRateList{
+			"GERMANY": []*engine.RPRate{
+				&engine.RPRate{
+					Timing: "59a981b9",
+					Rating: "ebefae11",
+					Weight: 10,
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.SetRatingPlan(rp, utils.NonTransactional); err != nil {
+			t.Error("Error when setting RatingPlan ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for RatingPlan ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaRatingPlans})
+		if err != nil {
+			t.Error("Error when migrating RatingPlan ", err.Error())
+		}
+		result, err := mig.dmOut.GetRatingPlan(rp.Id, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting RatingPlan ", err.Error())
+		}
+		if !reflect.DeepEqual(rp, result) {
+			t.Errorf("Expecting: %v, received: %v", rp, result)
+		}
+	}
+}
+
+func testMigratorRatingProfile(t *testing.T) {
+	rpf := &engine.RatingProfile{
+		Id: "*out:test:1:trp",
+		RatingPlanActivations: engine.RatingPlanActivations{
+			&engine.RatingPlanActivation{
+				ActivationTime:  time.Date(2013, 10, 1, 0, 0, 0, 0, time.UTC).Local(),
+				RatingPlanId:    "TDRT",
+				FallbackKeys:    []string{"*out:test:1:danb", "*out:test:1:rif"},
+				CdrStatQueueIds: []string{},
+			}},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.SetRatingProfile(rpf, utils.NonTransactional); err != nil {
+			t.Error("Error when setting RatingProfile ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for RatingProfile ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaRatingProfile})
+		if err != nil {
+			t.Error("Error when migrating RatingProfile ", err.Error())
+		}
+		result, err := mig.dmOut.GetRatingProfile(rpf.Id, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting RatingProfile ", err.Error())
+		}
+		if !reflect.DeepEqual(rpf, result) {
+			t.Errorf("Expecting: %v, received: %v", rpf, result)
+		}
+	}
+}
+func testMigratorRQF(t *testing.T) {
+	fp := &engine.Filter{
+		Tenant: "cgrates.org",
+		ID:     "Filter1",
+		RequestFilters: []*engine.RequestFilter{
+			&engine.RequestFilter{
+				FieldName: "Account",
+				Type:      "*string",
+				Values:    []string{"1001", "1002"},
+			},
+		},
+		ActivationInterval: &utils.ActivationInterval{
+			ActivationTime: time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC).Local(),
+			ExpiryTime:     time.Date(2014, 7, 14, 14, 25, 0, 0, time.UTC).Local(),
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.SetFilter(fp); err != nil {
+			t.Error("Error when setting RequestFilter ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for RequestFilter ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaRQF})
+		if err != nil {
+			t.Error("Error when migrating RequestFilter ", err.Error())
+		}
+		result, err := mig.dmOut.GetFilter(fp.Tenant, fp.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting RequestFilter ", err.Error())
+		}
+		if !reflect.DeepEqual(fp, result) {
+			t.Errorf("Expecting: %v, received: %v", fp, result)
+		}
+	}
+}
+
+func testMigratorResource(t *testing.T) {
+	rL := &engine.ResourceProfile{
+		Tenant:    "cgrates.org",
+		ID:        "RL_TEST2",
+		Weight:    10,
+		FilterIDs: []string{"FLTR_RES_RL_TEST2"},
+		ActivationInterval: &utils.ActivationInterval{
+			ActivationTime: time.Date(2014, 7, 3, 13, 43, 0, 0, time.UTC).Local(),
+			ExpiryTime:     time.Date(2015, 7, 3, 13, 43, 0, 0, time.UTC).Local()},
+		Limit:      1,
+		Thresholds: []string{"TEST_ACTIONS"},
+		UsageTTL:   time.Duration(1 * time.Millisecond),
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.SetResourceProfile(rL); err != nil {
+			t.Error("Error when setting ResourceProfile ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for ResourceProfile ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaResource})
+		if err != nil {
+			t.Error("Error when migrating ResourceProfile ", err.Error())
+		}
+		result, err := mig.dmOut.GetResourceProfile(rL.Tenant, rL.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting ResourceProfile ", err.Error())
+		}
+		if !reflect.DeepEqual(rL, result) {
+			t.Errorf("Expecting: %v, received: %v", rL, result)
+		}
+	}
+}
+
+func testMigratorSubscribers(t *testing.T) {
+	sbsc := &engine.SubscriberData{
+		ExpTime: time.Date(2012, 1, 1, 0, 0, 0, 0, time.UTC).Local(),
+		Filters: utils.ParseRSRFieldsMustCompile("^*default", utils.INFIELD_SEP)}
+	sbscID := "testOnStorITCRUDSubscribers"
+
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.SetSubscriber(sbscID, sbsc); err != nil {
+			t.Error("Error when setting RatingProfile ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for RatingProfile ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaSubscribers})
+		if err != nil {
+			t.Error("Error when migrating RatingProfile ", err.Error())
+		}
+		result, err := mig.dmOut.GetSubscribers()
+		if err != nil {
+			t.Error("Error when getting RatingProfile ", err.Error())
+		}
+		if !reflect.DeepEqual(sbsc.ExpTime, result["testOnStorITCRUDSubscribers"].ExpTime) {
+			t.Errorf("Expecting: %v, received: %v", sbsc.ExpTime, result["testOnStorITCRUDSubscribers"].ExpTime)
+		} else if !reflect.DeepEqual(sbsc.Filters[0].Id, result["testOnStorITCRUDSubscribers"].Filters[0].Id) {
+			t.Errorf("Expecting: %v, received: %v", sbsc.Filters[0].Id, result["testOnStorITCRUDSubscribers"].Filters[0].Id)
+		}
+	}
+}
+
+func testMigratorTimings(t *testing.T) {
+	tmg := &utils.TPTiming{
+		ID:        "TEST_TMG",
+		Years:     utils.Years{2016, 2017},
+		Months:    utils.Months{time.January, time.February, time.March},
+		MonthDays: utils.MonthDays{1, 2, 3, 4},
+		WeekDays:  utils.WeekDays{},
+		StartTime: "00:00:00",
+		EndTime:   "",
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.dmIN.SetTiming(tmg); err != nil {
+			t.Error("Error when setting Timings ", err.Error())
+		}
+		currentVersion := engine.CurrentDataDBVersions()
+		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for Timings ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTiming})
+		if err != nil {
+			t.Error("Error when migrating Timings ", err.Error())
+		}
+		result, err := mig.dmOut.GetTiming(tmg.ID, true, utils.NonTransactional)
+		if err != nil {
+			t.Error("Error when getting Timings ", err.Error())
+		}
+		if !reflect.DeepEqual(tmg, result) {
+			t.Errorf("Expecting: %v, received: %v", tmg, result)
+		}
+	}
+}
+
+//TP TESTS
+func testMigratorTPRatingProfile(t *testing.T) {
+	tpRatingProfile := []*utils.TPRatingProfile{
+		&utils.TPRatingProfile{
+			TPid:      "TPRProf1",
+			LoadId:    "RPrf",
+			Direction: "*out",
+			Tenant:    "Tenant1",
+			Category:  "Category",
+			Subject:   "Subject",
+			RatingPlanActivations: []*utils.TPRatingActivation{
+				&utils.TPRatingActivation{
+					ActivationTime:   "2014-07-29T15:00:00Z",
+					RatingPlanId:     "PlanOne",
+					FallbackSubjects: "FallBack",
+					CdrStatQueueIds:  "RandomId",
+				},
+				&utils.TPRatingActivation{
+					ActivationTime:   "2015-07-29T10:00:00Z",
+					RatingPlanId:     "PlanTwo",
+					FallbackSubjects: "FallOut",
+					CdrStatQueueIds:  "RandomIdTwo",
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPRatingProfiles(tpRatingProfile); err != nil {
+			t.Error("Error when setting Stats ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
 		if err != nil {
 			t.Error("Error when setting version for stats ", err.Error())
 		}
@@ -1037,12 +1863,12 @@ func testMigratorTPRatingProfile(t *testing.T) {
 		if err != nil {
 			t.Error("Error when migrating Stats ", err.Error())
 		}
-		result, err := mig.OutStorDB().GetTPRatingProfiles(tpRatingProfile)
+		result, err := mig.OutStorDB().GetTPRatingProfiles(tpRatingProfile[0])
 		if err != nil {
 			t.Error("Error when getting Stats ", err.Error())
 		}
-		if !reflect.DeepEqual(tpRatingProfile, result[0]) {
-			t.Errorf("Expecting: %+v, received: %+v", tpRatingProfile, result[0])
+		if !reflect.DeepEqual(tpRatingProfile[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRatingProfile[0], result[0])
 		}
 	}
 }
@@ -1078,16 +1904,16 @@ func testMigratorTPSuppliers(t *testing.T) {
 	switch dbtype {
 	case Move:
 		if err := mig.InStorDB().SetTPSuppliers(tpSplPr); err != nil {
-			t.Error("Error when setting Stats ", err.Error())
+			t.Error("Error when setting TpSupplier ", err.Error())
 		}
-		currentVersion := engine.CurrentDataDBVersions()
-		err := mig.dmOut.DataDB().SetVersions(currentVersion, false)
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
 		if err != nil {
-			t.Error("Error when setting version for stats ", err.Error())
+			t.Error("Error when setting version for TpSupplier ", err.Error())
 		}
 		err, _ = mig.Migrate([]string{utils.MetaTpSuppliers})
 		if err != nil {
-			t.Error("Error when migrating Stats ", err.Error())
+			t.Error("Error when migrating TpSupplier ", err.Error())
 		}
 		result, err := mig.OutStorDB().GetTPSuppliers(tpSplPr[0].TPid, tpSplPr[0].ID)
 		if err != nil {
@@ -1098,3 +1924,1026 @@ func testMigratorTPSuppliers(t *testing.T) {
 		}
 	}
 }
+
+func testMigratorTPActions(t *testing.T) {
+	tpActions := []*utils.TPActions{
+		&utils.TPActions{
+			TPid: "TPAcc",
+			ID:   "ID",
+			Actions: []*utils.TPAction{
+				&utils.TPAction{
+					Identifier:      "*topup_reset",
+					BalanceId:       "BalID",
+					BalanceType:     "*data",
+					Directions:      "*out",
+					Units:           "10",
+					ExpiryTime:      "*unlimited",
+					Filter:          "",
+					TimingTags:      "2014-01-14T00:00:00Z",
+					DestinationIds:  "DST_1002",
+					RatingSubject:   "SPECIAL_1002",
+					Categories:      "",
+					SharedGroups:    "SHARED_A",
+					BalanceWeight:   "10",
+					ExtraParameters: "",
+					BalanceBlocker:  "false",
+					BalanceDisabled: "false",
+					Weight:          10,
+				},
+				&utils.TPAction{
+					Identifier:      "*log",
+					BalanceId:       "BalID",
+					BalanceType:     "*monetary",
+					Directions:      "*out",
+					Units:           "120",
+					ExpiryTime:      "*unlimited",
+					Filter:          "",
+					TimingTags:      "2014-01-14T00:00:00Z",
+					DestinationIds:  "*any",
+					RatingSubject:   "SPECIAL_1002",
+					Categories:      "",
+					SharedGroups:    "SHARED_A",
+					BalanceWeight:   "11",
+					ExtraParameters: "",
+					BalanceBlocker:  "false",
+					BalanceDisabled: "false",
+					Weight:          11,
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPActions(tpActions); err != nil {
+			t.Error("Error when setting TpActions ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpActions ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpActions})
+		if err != nil {
+			t.Error("Error when migrating TpActions ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPActions(tpActions[0].TPid, tpActions[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpActions ", err.Error())
+		}
+		if !reflect.DeepEqual(tpActions[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpActions[0], result[0])
+		}
+	}
+}
+
+func testMigratorTPAccountActions(t *testing.T) {
+	tpAccActions := []*utils.TPAccountActions{
+		&utils.TPAccountActions{
+			TPid:             "TPAcc",
+			LoadId:           "ID",
+			Tenant:           "cgrates.org",
+			Account:          "1001",
+			ActionPlanId:     "PREPAID_10",
+			ActionTriggersId: "STANDARD_TRIGGERS",
+			AllowNegative:    true,
+			Disabled:         false,
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPAccountActions(tpAccActions); err != nil {
+			t.Error("Error when setting TpAccountActions ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpAccountActions ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpAccountActions})
+		if err != nil {
+			t.Error("Error when migrating TpAccountActions ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPAccountActions(&utils.TPAccountActions{TPid: "TPAcc"})
+		if err != nil {
+			t.Error("Error when getting TpAccountActions ", err.Error())
+		}
+		if !reflect.DeepEqual(tpAccActions[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpAccActions[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpActionTriggers(t *testing.T) {
+	tpActionTriggers := []*utils.TPActionTriggers{
+		&utils.TPActionTriggers{
+			TPid: "TPAct",
+			ID:   "STANDARD_TRIGGERS",
+			ActionTriggers: []*utils.TPActionTrigger{
+				&utils.TPActionTrigger{
+					Id:                    "STANDARD_TRIGGERS",
+					UniqueID:              "",
+					ThresholdType:         "*min_balance",
+					ThresholdValue:        2,
+					Recurrent:             false,
+					MinSleep:              "0",
+					ExpirationDate:        "",
+					ActivationDate:        "",
+					BalanceId:             "",
+					BalanceType:           "*monetary",
+					BalanceDirections:     "*out",
+					BalanceDestinationIds: "FS_USERS",
+					BalanceWeight:         "",
+					BalanceExpirationDate: "",
+					BalanceTimingTags:     "",
+					BalanceRatingSubject:  "",
+					BalanceCategories:     "",
+					BalanceSharedGroups:   "",
+					BalanceBlocker:        "",
+					BalanceDisabled:       "",
+					MinQueuedItems:        3,
+					ActionsId:             "LOG_WARNING",
+					Weight:                10,
+				},
+				&utils.TPActionTrigger{
+					Id:                    "STANDARD_TRIGGERS",
+					UniqueID:              "",
+					ThresholdType:         "*max_event_counter",
+					ThresholdValue:        5,
+					Recurrent:             false,
+					MinSleep:              "0",
+					ExpirationDate:        "",
+					ActivationDate:        "",
+					BalanceId:             "",
+					BalanceType:           "*monetary",
+					BalanceDirections:     "*out",
+					BalanceDestinationIds: "FS_USERS",
+					BalanceWeight:         "",
+					BalanceExpirationDate: "",
+					BalanceTimingTags:     "",
+					BalanceRatingSubject:  "",
+					BalanceCategories:     "",
+					BalanceSharedGroups:   "",
+					BalanceBlocker:        "",
+					BalanceDisabled:       "",
+					MinQueuedItems:        3,
+					ActionsId:             "LOG_WARNING",
+					Weight:                10,
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPActionTriggers(tpActionTriggers); err != nil {
+			t.Error("Error when setting TpActionTriggers ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpActionTriggers ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpActionTriggers})
+		if err != nil {
+			t.Error("Error when migrating TpActionTriggers ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPActionTriggers(tpActionTriggers[0].TPid, tpActionTriggers[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpAccountActions ", err.Error())
+		}
+		if !reflect.DeepEqual(tpActionTriggers[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpActionTriggers[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpActionPlans(t *testing.T) {
+	tpAccPlan := []*utils.TPActionPlan{
+		&utils.TPActionPlan{
+			TPid: "TPAcc",
+			ID:   "ID",
+			ActionPlan: []*utils.TPActionTiming{
+				&utils.TPActionTiming{
+					ActionsId: "AccId",
+					TimingId:  "TimingID",
+					Weight:    10,
+				},
+				&utils.TPActionTiming{
+					ActionsId: "AccId2",
+					TimingId:  "TimingID2",
+					Weight:    11,
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPActionPlans(tpAccPlan); err != nil {
+			t.Error("Error when setting TpActionPlans ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpActionPlans ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpActionPlans})
+		if err != nil {
+			t.Error("Error when migrating TpActionPlans ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPActionPlans(tpAccPlan[0].TPid, tpAccPlan[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpActionPlans ", err.Error())
+		}
+		if !reflect.DeepEqual(tpAccPlan[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpAccPlan[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpUsers(t *testing.T) {
+	tpUser := []*utils.TPUsers{
+		&utils.TPUsers{
+			TPid:     "TPU1",
+			UserName: "User1",
+			Tenant:   "Tenant1",
+			Masked:   true,
+			Weight:   20,
+			Profile: []*utils.TPUserProfile{
+				&utils.TPUserProfile{
+					AttrName:  "UserProfile1",
+					AttrValue: "ValUP1",
+				},
+				&utils.TPUserProfile{
+					AttrName:  "UserProfile2",
+					AttrValue: "ValUP2",
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPUsers(tpUser); err != nil {
+			t.Error("Error when setting TpUsers ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpUsers ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpUsers})
+		if err != nil {
+			t.Error("Error when migrating TpUsers ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPUsers(&utils.TPUsers{TPid: tpUser[0].TPid})
+		if err != nil {
+			t.Error("Error when getting TpUsers ", err.Error())
+		}
+		if !reflect.DeepEqual(tpUser[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpUser[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpTimings(t *testing.T) {
+	tpTiming := []*utils.ApierTPTiming{&utils.ApierTPTiming{
+		TPid:      "TPT1",
+		ID:        "Timing",
+		Years:     "2017",
+		Months:    "05",
+		MonthDays: "01",
+		WeekDays:  "1",
+		Time:      "15:00:00Z",
+	},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPTimings(tpTiming); err != nil {
+			t.Error("Error when setting TpTiming ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpTiming ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpTiming})
+		if err != nil {
+			t.Error("Error when migrating TpTiming ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPTimings(tpTiming[0].TPid, tpTiming[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpTiming ", err.Error())
+		}
+		if !reflect.DeepEqual(tpTiming[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpTiming[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpThreshold(t *testing.T) {
+	tpThreshold := []*utils.TPThreshold{
+		&utils.TPThreshold{
+			TPid:      "TH1",
+			Tenant:    "cgrates.org",
+			ID:        "Threhold",
+			FilterIDs: []string{"FLTR_1", "FLTR_2"},
+			ActivationInterval: &utils.TPActivationInterval{
+				ActivationTime: "2014-07-29T15:00:00Z",
+				ExpiryTime:     "",
+			},
+			Recurrent: true,
+			MinSleep:  "1s",
+			Blocker:   true,
+			Weight:    10,
+			ActionIDs: []string{"Thresh1", "Thresh2"},
+			Async:     true,
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPThresholds(tpThreshold); err != nil {
+			t.Error("Error when setting TpThreshold ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpThreshold ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpThresholds})
+		if err != nil {
+			t.Error("Error when migrating TpThreshold ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPThresholds(tpThreshold[0].TPid, tpThreshold[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpThreshold ", err.Error())
+		}
+		if !reflect.DeepEqual(tpThreshold[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpThreshold[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpStats(t *testing.T) {
+	tpStat := []*utils.TPStats{
+		&utils.TPStats{
+			Tenant:    "cgrates.org",
+			TPid:      "TPS1",
+			ID:        "Stat1",
+			FilterIDs: []string{"FLTR_1"},
+			ActivationInterval: &utils.TPActivationInterval{
+				ActivationTime: "2014-07-29T15:00:00Z",
+				ExpiryTime:     "",
+			},
+			TTL:        "1",
+			Metrics:    []string{"MetricValue", "MetricValueTwo"},
+			Blocker:    false,
+			Stored:     false,
+			Weight:     20,
+			MinItems:   1,
+			Thresholds: []string{"ThreshValue", "ThreshValueTwo"},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPStats(tpStat); err != nil {
+			t.Error("Error when setting TpStats ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpStats ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpStats})
+		if err != nil {
+			t.Error("Error when migrating TpStats ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPStats(tpStat[0].TPid, tpStat[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpStats ", err.Error())
+		}
+		if !reflect.DeepEqual(tpStat[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpStat[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpSharedGroups(t *testing.T) {
+	tpSharedGroups := []*utils.TPSharedGroups{
+		&utils.TPSharedGroups{
+			TPid: "Tpi",
+			ID:   "TpSg",
+			SharedGroups: []*utils.TPSharedGroup{
+				&utils.TPSharedGroup{
+					Account:       "AccOne",
+					Strategy:      "StrategyOne",
+					RatingSubject: "SubOne",
+				},
+				&utils.TPSharedGroup{
+					Account:       "AccTow",
+					Strategy:      "StrategyTwo",
+					RatingSubject: "SubTwo",
+				},
+				&utils.TPSharedGroup{
+					Account:       "AccPlus",
+					Strategy:      "StrategyPlus",
+					RatingSubject: "SubPlus",
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPSharedGroups(tpSharedGroups); err != nil {
+			t.Error("Error when setting TpSharedGroups ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpSharedGroups ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpSharedGroups})
+		if err != nil {
+			t.Error("Error when migrating TpSharedGroups ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPSharedGroups(tpSharedGroups[0].TPid, tpSharedGroups[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpSharedGroups ", err.Error())
+		}
+		if !reflect.DeepEqual(tpSharedGroups[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpSharedGroups[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpResources(t *testing.T) {
+	tpRes := []*utils.TPResource{
+		&utils.TPResource{
+			Tenant:    "cgrates.org",
+			TPid:      "TPR1",
+			ID:        "ResGroup1",
+			FilterIDs: []string{"FLTR_1"},
+			ActivationInterval: &utils.TPActivationInterval{
+				ActivationTime: "2014-07-29T15:00:00Z",
+				ExpiryTime:     "",
+			},
+			UsageTTL:          "1s",
+			Limit:             "7",
+			AllocationMessage: "",
+			Blocker:           true,
+			Stored:            true,
+			Weight:            20,
+			Thresholds:        []string{"ValOne", "ValTwo"},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPResources(tpRes); err != nil {
+			t.Error("Error when setting TpResources ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpResources ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpResources})
+		if err != nil {
+			t.Error("Error when migrating TpResources ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPResources(tpRes[0].TPid, tpRes[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpResources ", err.Error())
+		}
+		if !reflect.DeepEqual(tpRes[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRes[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpRatingProfiles(t *testing.T) {
+	tpRatingProfile := []*utils.TPRatingProfile{
+		&utils.TPRatingProfile{
+			TPid:      "TPRProf1",
+			LoadId:    "RPrf",
+			Direction: "*out",
+			Tenant:    "Tenant1",
+			Category:  "Category",
+			Subject:   "Subject",
+			RatingPlanActivations: []*utils.TPRatingActivation{
+				&utils.TPRatingActivation{
+					ActivationTime:   "2014-07-29T15:00:00Z",
+					RatingPlanId:     "PlanOne",
+					FallbackSubjects: "FallBack",
+					CdrStatQueueIds:  "RandomId",
+				},
+				&utils.TPRatingActivation{
+					ActivationTime:   "2015-07-29T10:00:00Z",
+					RatingPlanId:     "PlanTwo",
+					FallbackSubjects: "FallOut",
+					CdrStatQueueIds:  "RandomIdTwo",
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPRatingProfiles(tpRatingProfile); err != nil {
+			t.Error("Error when setting TpRatingProfiles ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpRatingProfiles ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpRatingProfiles})
+		if err != nil {
+			t.Error("Error when migrating TpRatingProfiles ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPRatingProfiles(&utils.TPRatingProfile{TPid: tpRatingProfile[0].TPid})
+		if err != nil {
+			t.Error("Error when getting TpRatingProfiles ", err.Error())
+		}
+		if !reflect.DeepEqual(tpRatingProfile[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRatingProfile[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpRatingPlans(t *testing.T) {
+	tpRatingPlan := []*utils.TPRatingPlan{
+		&utils.TPRatingPlan{
+			TPid: "TPRP1",
+			ID:   "Plan1",
+			RatingPlanBindings: []*utils.TPRatingPlanBinding{
+				&utils.TPRatingPlanBinding{
+					DestinationRatesId: "RateId",
+					TimingId:           "TimingID",
+					Weight:             12,
+				},
+				&utils.TPRatingPlanBinding{
+					DestinationRatesId: "DR_FREESWITCH_USERS",
+					TimingId:           "ALWAYS",
+					Weight:             10,
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPRatingPlans(tpRatingPlan); err != nil {
+			t.Error("Error when setting TpRatingPlans ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpRatingPlans ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpRatingPlans})
+		if err != nil {
+			t.Error("Error when migrating TpRatingPlans ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPRatingPlans("TPRP1", "Plan1", nil)
+		if err != nil {
+			t.Error("Error when getting TpRatingPlans ", err.Error())
+		}
+		if !reflect.DeepEqual(tpRatingPlan[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRatingPlan[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpRates(t *testing.T) {
+	tpRate := []*utils.TPRate{
+		&utils.TPRate{
+			TPid: "TPidTpRate",
+			ID:   "RT_FS_USERS",
+			RateSlots: []*utils.RateSlot{
+				&utils.RateSlot{
+					ConnectFee:         12,
+					Rate:               3,
+					RateUnit:           "6s",
+					RateIncrement:      "6s",
+					GroupIntervalStart: "0s",
+				},
+				&utils.RateSlot{
+					ConnectFee:         12,
+					Rate:               3,
+					RateUnit:           "4s",
+					RateIncrement:      "6s",
+					GroupIntervalStart: "1s",
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPRates(tpRate); err != nil {
+			t.Error("Error when setting TpRates ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpRates ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpRates})
+		if err != nil {
+			t.Error("Error when migrating TpRates ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPRates(tpRate[0].TPid, tpRate[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpRates ", err.Error())
+		}
+		if !reflect.DeepEqual(tpRate[0].TPid, result[0].TPid) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].TPid, result[0].TPid)
+		} else if !reflect.DeepEqual(tpRate[0].ID, result[0].ID) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].ID, result[0].ID)
+		}
+		if !reflect.DeepEqual(tpRate[0].RateSlots[0].ConnectFee, result[0].RateSlots[0].ConnectFee) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[0].ConnectFee, result[0].RateSlots[0].ConnectFee)
+		} else if !reflect.DeepEqual(tpRate[0].RateSlots[0].Rate, result[0].RateSlots[0].Rate) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[0].Rate, result[0].RateSlots[0].Rate)
+		} else if !reflect.DeepEqual(tpRate[0].RateSlots[0].RateUnit, result[0].RateSlots[0].RateUnit) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[0].RateUnit, result[0].RateSlots[0].RateUnit)
+		} else if !reflect.DeepEqual(tpRate[0].RateSlots[0].RateIncrement, result[0].RateSlots[0].RateIncrement) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[0].RateIncrement, result[0].RateSlots[0].RateIncrement)
+		} else if !reflect.DeepEqual(tpRate[0].RateSlots[0].GroupIntervalStart, result[0].RateSlots[0].GroupIntervalStart) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[0].GroupIntervalStart, result[0].RateSlots[0].GroupIntervalStart)
+		}
+		if !reflect.DeepEqual(tpRate[0].RateSlots[1].ConnectFee, result[0].RateSlots[1].ConnectFee) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[1].ConnectFee, result[0].RateSlots[1].ConnectFee)
+		} else if !reflect.DeepEqual(tpRate[0].RateSlots[1].Rate, result[0].RateSlots[1].Rate) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[1].Rate, result[0].RateSlots[1].Rate)
+		} else if !reflect.DeepEqual(tpRate[0].RateSlots[1].RateUnit, result[0].RateSlots[1].RateUnit) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[1].RateUnit, result[0].RateSlots[1].RateUnit)
+		} else if !reflect.DeepEqual(tpRate[0].RateSlots[1].RateIncrement, result[0].RateSlots[1].RateIncrement) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[1].RateIncrement, result[0].RateSlots[1].RateIncrement)
+		} else if !reflect.DeepEqual(tpRate[0].RateSlots[1].GroupIntervalStart, result[0].RateSlots[1].GroupIntervalStart) {
+			t.Errorf("Expecting: %+v, received: %+v", tpRate[0].RateSlots[1].GroupIntervalStart, result[0].RateSlots[1].GroupIntervalStart)
+		}
+	}
+}
+
+func testMigratorTpLCRRules(t *testing.T) {
+	tpLcrRules := []*utils.TPLcrRules{
+		&utils.TPLcrRules{
+			TPid:      "TPLRC1",
+			Direction: "*out",
+			Tenant:    "cgrates.org",
+			Category:  "call",
+			Account:   "1001",
+			Subject:   "*any",
+			Rules: []*utils.TPLcrRule{
+				&utils.TPLcrRule{
+					DestinationId:  "DST_1002",
+					RpCategory:     "lcr_profile1",
+					Strategy:       "*static",
+					StrategyParams: "suppl2;suppl1",
+					ActivationTime: "05:00:00",
+					Weight:         10,
+				},
+				&utils.TPLcrRule{
+					DestinationId:  "*any",
+					RpCategory:     "lcr_profile1",
+					Strategy:       "*highest_cost",
+					StrategyParams: "",
+					ActivationTime: "05:00:00",
+					Weight:         10,
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPLCRs(tpLcrRules); err != nil {
+			t.Error("Error when setting TpLCRRules ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpLCRRules ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpLCRRules})
+		if err != nil {
+			t.Error("Error when migrating TpLCRRules ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPLCRs(&utils.TPLcrRules{TPid: tpLcrRules[0].TPid})
+		if err != nil {
+			t.Error("Error when getting TpLCRRules ", err.Error())
+		}
+		if !reflect.DeepEqual(tpLcrRules[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpLcrRules[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpFilter(t *testing.T) {
+	tpFilter := []*utils.TPFilter{
+		&utils.TPFilter{
+			TPid:   "TP1",
+			Tenant: "cgrates.org",
+			ID:     "Filter",
+			Filters: []*utils.TPRequestFilter{
+				&utils.TPRequestFilter{
+					Type:      "*string",
+					FieldName: "Account",
+					Values:    []string{"1001", "1002"},
+				},
+			},
+			ActivationInterval: &utils.TPActivationInterval{
+				ActivationTime: "2014-07-29T15:00:00Z",
+				ExpiryTime:     "",
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPFilters(tpFilter); err != nil {
+			t.Error("Error when setting TpFilter ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpFilter ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpFilters})
+		if err != nil {
+			t.Error("Error when migrating TpFilter ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPFilters(tpFilter[0].TPid, tpFilter[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpFilter ", err.Error())
+		}
+		if !reflect.DeepEqual(tpFilter[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpFilter[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpDestination(t *testing.T) {
+	tpDestination := []*utils.TPDestination{
+		&utils.TPDestination{
+			TPid:     "TPD",
+			ID:       "GERMANY",
+			Prefixes: []string{"+49", "+4915"},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPDestinations(tpDestination); err != nil {
+			t.Error("Error when setting TpDestination ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpDestination ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpDestinations})
+		if err != nil {
+			t.Error("Error when migrating TpDestination ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPDestinations(tpDestination[0].TPid, tpDestination[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpDestination ", err.Error())
+		}
+		if !reflect.DeepEqual(tpDestination[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpDestination[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpDestinationRate(t *testing.T) {
+	tpDestRate := []*utils.TPDestinationRate{
+		&utils.TPDestinationRate{
+			TPid: "testTPid",
+			ID:   "1",
+			DestinationRates: []*utils.DestinationRate{
+				&utils.DestinationRate{
+					DestinationId:    "GERMANY",
+					RateId:           "RT_1CENT",
+					RoundingMethod:   "*up",
+					RoundingDecimals: 0,
+					MaxCost:          0.0,
+					MaxCostStrategy:  "",
+				},
+			},
+		},
+	}
+
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPDestinationRates(tpDestRate); err != nil {
+			t.Error("Error when setting TpDestinationRate ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpDestinationRate ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpDestinationRates})
+		if err != nil {
+			t.Error("Error when migrating TpDestinationRate ", err.Error())
+		} //OutStorDB
+		result, err := mig.InStorDB().GetTPDestinationRates("testTPid", "", nil)
+		if err != nil {
+			t.Error("Error when getting TpDestinationRate ", err.Error())
+		}
+		if !reflect.DeepEqual(tpDestRate[0].TPid, result[0].TPid) {
+			t.Errorf("Expecting: %+v, received: %+v", tpDestRate[0].TPid, result[0].TPid)
+		} else if !reflect.DeepEqual(tpDestRate[0].ID, result[0].ID) {
+			t.Errorf("Expecting: %+v, received: %+v", tpDestRate[0].ID, result[0].ID)
+		}
+		if !reflect.DeepEqual(tpDestRate[0].DestinationRates[0].DestinationId, result[0].DestinationRates[0].DestinationId) {
+			t.Errorf("Expecting: %+v, received: %+v", tpDestRate[0].DestinationRates[0].DestinationId, result[0].DestinationRates[0].DestinationId)
+		} else if !reflect.DeepEqual(tpDestRate[0].DestinationRates[0].RateId, result[0].DestinationRates[0].RateId) {
+			t.Errorf("Expecting: %+v, received: %+v", tpDestRate[0].DestinationRates[0].RateId, result[0].DestinationRates[0].RateId)
+		} else if !reflect.DeepEqual(tpDestRate[0].DestinationRates[0], result[0].DestinationRates[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpDestRate[0].DestinationRates[0], result[0].DestinationRates[0])
+		}
+	}
+}
+
+func testMigratorTpDerivedChargers(t *testing.T) {
+	tpDerivedChargers := []*utils.TPDerivedChargers{
+		&utils.TPDerivedChargers{
+			TPid:           "TPD",
+			LoadId:         "LoadID",
+			Direction:      "*out",
+			Tenant:         "cgrates.org",
+			Category:       "call",
+			Account:        "1001",
+			Subject:        "1001",
+			DestinationIds: "",
+			DerivedChargers: []*utils.TPDerivedCharger{
+				&utils.TPDerivedCharger{
+					RunId:                "derived_run1",
+					RunFilters:           "",
+					ReqTypeField:         "^*rated",
+					DirectionField:       "*default",
+					TenantField:          "*default",
+					CategoryField:        "*default",
+					AccountField:         "*default",
+					SubjectField:         "^1002",
+					DestinationField:     "*default",
+					SetupTimeField:       "*default",
+					PddField:             "*default",
+					AnswerTimeField:      "*default",
+					UsageField:           "*default",
+					SupplierField:        "*default",
+					DisconnectCauseField: "*default",
+					CostField:            "*default",
+					RatedField:           "*default",
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPDerivedChargers(tpDerivedChargers); err != nil {
+			t.Error("Error when setting TpDerivedChargers ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpDerivedChargers ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpDerivedChargers})
+		if err != nil {
+			t.Error("Error when migrating TpDerivedChargers ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPDerivedChargers(&utils.TPDerivedChargers{TPid: tpDerivedChargers[0].TPid})
+		if err != nil {
+			t.Error("Error when getting TpDerivedChargers ", err.Error())
+		}
+		if !reflect.DeepEqual(tpDerivedChargers[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpDerivedChargers[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpCdrStats(t *testing.T) {
+	tpCdrStats := []*utils.TPCdrStats{
+		&utils.TPCdrStats{
+			TPid: "TPCdr",
+			ID:   "ID",
+			CdrStats: []*utils.TPCdrStat{
+				&utils.TPCdrStat{
+					QueueLength:      "10",
+					TimeWindow:       "0",
+					SaveInterval:     "10s",
+					Metrics:          "ASR",
+					SetupInterval:    "",
+					TORs:             "",
+					CdrHosts:         "",
+					CdrSources:       "",
+					ReqTypes:         "",
+					Directions:       "",
+					Tenants:          "cgrates.org",
+					Categories:       "",
+					Accounts:         "",
+					Subjects:         "1001",
+					DestinationIds:   "1003",
+					PddInterval:      "",
+					UsageInterval:    "",
+					Suppliers:        "suppl1",
+					DisconnectCauses: "",
+					MediationRunIds:  "*default",
+					RatedAccounts:    "",
+					RatedSubjects:    "",
+					CostInterval:     "",
+					ActionTriggers:   "CDRST1_WARN",
+				},
+				&utils.TPCdrStat{
+					QueueLength:      "10",
+					TimeWindow:       "0",
+					SaveInterval:     "10s",
+					Metrics:          "ACC",
+					SetupInterval:    "",
+					TORs:             "",
+					CdrHosts:         "",
+					CdrSources:       "",
+					ReqTypes:         "",
+					Directions:       "",
+					Tenants:          "cgrates.org",
+					Categories:       "",
+					Accounts:         "",
+					Subjects:         "1002",
+					DestinationIds:   "1003",
+					PddInterval:      "",
+					UsageInterval:    "",
+					Suppliers:        "suppl1",
+					DisconnectCauses: "",
+					MediationRunIds:  "*default",
+					RatedAccounts:    "",
+					RatedSubjects:    "",
+					CostInterval:     "",
+					ActionTriggers:   "CDRST1_WARN",
+				},
+			},
+		},
+	}
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPCdrStats(tpCdrStats); err != nil {
+			t.Error("Error when setting TpCdrStats ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpCdrStats ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpCdrStats})
+		if err != nil {
+			t.Error("Error when migrating TpCdrStats ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPCdrStats(tpCdrStats[0].TPid, tpCdrStats[0].ID)
+		if err != nil {
+			t.Error("Error when getting TpCdrStats ", err.Error())
+		}
+		if !reflect.DeepEqual(tpCdrStats[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpCdrStats[0], result[0])
+		}
+	}
+}
+
+func testMigratorTpAliases(t *testing.T) {
+	tpAliases := []*utils.TPAliases{
+		&utils.TPAliases{
+			TPid:      "tpID",
+			Direction: "*out",
+			Tenant:    "cgrates.org",
+			Category:  "call",
+			Account:   "1001",
+			Subject:   "1002",
+			Context:   "",
+			Values: []*utils.TPAliasValue{
+				&utils.TPAliasValue{
+					DestinationId: "1002",
+					Target:        "1002",
+					Original:      "1002",
+					Alias:         "1002",
+					Weight:        20.0,
+				},
+			},
+		},
+	}
+
+	switch dbtype {
+	case Move:
+		if err := mig.InStorDB().SetTPAliases(tpAliases); err != nil {
+			t.Error("Error when setting TpAliases ", err.Error())
+		}
+		currentVersion := engine.CurrentStorDBVersions()
+		err := mig.OutStorDB().SetVersions(currentVersion, false)
+		if err != nil {
+			t.Error("Error when setting version for TpAliases ", err.Error())
+		}
+		err, _ = mig.Migrate([]string{utils.MetaTpAliases})
+		if err != nil {
+			t.Error("Error when migrating TpAliases ", err.Error())
+		}
+		result, err := mig.OutStorDB().GetTPAliases(&utils.TPAliases{TPid: tpAliases[0].TPid})
+		if err != nil {
+			t.Error("Error when getting TpAliases ", err.Error())
+		}
+		if !reflect.DeepEqual(tpAliases[0], result[0]) {
+			t.Errorf("Expecting: %+v, received: %+v", tpAliases[0], result[0])
+		}
+	}
+}
diff --git a/migrator/resource.go b/migrator/resource.go
index 7a3501711..2f559506a 100644
--- a/migrator/resource.go
+++ b/migrator/resource.go
@@ -35,14 +35,14 @@ func (m *Migrator) migrateCurrentResource() (err error) {
 		return err
 	}
 	for _, id := range ids {
-		idg := strings.TrimPrefix(id, utils.ResourceProfilesPrefix)
-		res, err := m.dmIN.GetResource(tenant, idg, true, utils.NonTransactional)
+		idg := strings.TrimPrefix(id, utils.ResourceProfilesPrefix+tenant+":")
+		res, err := m.dmIN.GetResourceProfile(tenant, idg, true, utils.NonTransactional)
 		if err != nil {
 			return err
 		}
 		if res != nil {
 			if m.dryRun != true {
-				if err := m.dmOut.SetResource(res); err != nil {
+				if err := m.dmOut.SetResourceProfile(res); err != nil {
 					return err
 				}
 				m.stats[utils.Resource] += 1
diff --git a/migrator/thresholds.go b/migrator/thresholds.go
index ce8947863..7f57981cf 100644
--- a/migrator/thresholds.go
+++ b/migrator/thresholds.go
@@ -167,8 +167,9 @@ func (m *Migrator) migrateThresholds() (err error) {
 	return
 }
 func (v2ATR v2ActionTrigger) AsThreshold() (thp *engine.ThresholdProfile, th *engine.Threshold, filter *engine.Filter, err error) {
+	var filterIDS []string
 	var filters []*engine.RequestFilter
-	if *v2ATR.Balance.ID != "" {
+	if v2ATR.Balance.ID != nil && *v2ATR.Balance.ID != "" {
 		if v2ATR.Balance.Directions != nil {
 			x, err := engine.NewRequestFilter(engine.MetaRSRFields, "Directions", v2ATR.Balance.Directions.Slice())
 			if err != nil {
@@ -226,22 +227,23 @@ func (v2ATR v2ActionTrigger) AsThreshold() (thp *engine.ThresholdProfile, th *en
 			}
 			filters = append(filters, x)
 		}
-	}
-	filter = &engine.Filter{Tenant: config.CgrConfig().DefaultTenant, ID: *v2ATR.Balance.ID, RequestFilters: filters}
 
-	th = &engine.Threshold{
-		Tenant: config.CgrConfig().DefaultTenant,
-		ID:     v2ATR.ID,
-	}
+		filter = &engine.Filter{Tenant: config.CgrConfig().DefaultTenant, ID: *v2ATR.Balance.ID, RequestFilters: filters}
+		filterIDS = append(filterIDS, filter.ID)
 
+	}
 	thp = &engine.ThresholdProfile{
 		ID:                 v2ATR.ID,
 		Tenant:             config.CgrConfig().DefaultTenant,
 		Weight:             v2ATR.Weight,
 		ActivationInterval: &utils.ActivationInterval{ActivationTime: v2ATR.ActivationDate, ExpiryTime: v2ATR.ExpirationDate},
-		FilterIDs:          []string{filter.ID},
+		FilterIDs:          []string{},
 		MinSleep:           v2ATR.MinSleep,
 	}
+	th = &engine.Threshold{
+		Tenant: config.CgrConfig().DefaultTenant,
+		ID:     v2ATR.ID,
+	}
 	return thp, th, filter, nil
 }
 
diff --git a/migrator/tp_account_actions.go b/migrator/tp_account_actions.go
index 6eadd28a8..e5876fea9 100644
--- a/migrator/tp_account_actions.go
+++ b/migrator/tp_account_actions.go
@@ -25,8 +25,8 @@ import (
 	"github.com/cgrates/cgrates/utils"
 )
 
-func (m *Migrator) migrateCurrentTPaccountacction() (err error) {
-	tpids, err := m.InStorDB().GetTpIds(utils.TBLTPActionTriggers)
+func (m *Migrator) migrateCurrentTPaccountAcction() (err error) {
+	tpids, err := m.InStorDB().GetTpIds(utils.TBLTPAccountActions)
 	if err != nil {
 		return err
 	}
@@ -40,7 +40,7 @@ func (m *Migrator) migrateCurrentTPaccountacction() (err error) {
 				if err := m.OutStorDB().SetTPAccountActions(dest); err != nil {
 					return err
 				}
-				m.stats[utils.TpAccountActions] += 1
+				m.stats[utils.TpAccountActionsV] += 1
 			}
 		}
 	}
@@ -49,8 +49,8 @@ func (m *Migrator) migrateCurrentTPaccountacction() (err error) {
 
 func (m *Migrator) migrateTPaccountacction() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
@@ -62,12 +62,12 @@ func (m *Migrator) migrateTPaccountacction() (err error) {
 			utils.UndefinedVersion,
 			"version number is not defined for ActionTriggers model")
 	}
-	switch vrs[utils.TpAccountActions] {
-	case current[utils.TpAccountActions]:
+	switch vrs[utils.TpAccountActionsV] {
+	case current[utils.TpAccountActionsV]:
 		if m.sameStorDB {
 			return
 		}
-		if err := m.migrateCurrentTPaccountacction(); err != nil {
+		if err := m.migrateCurrentTPaccountAcction(); err != nil {
 			return err
 		}
 		return
diff --git a/migrator/tp_action_plans.go b/migrator/tp_action_plans.go
index 2ad475892..a15fca660 100644
--- a/migrator/tp_action_plans.go
+++ b/migrator/tp_action_plans.go
@@ -31,7 +31,7 @@ func (m *Migrator) migrateCurrentTPactionplans() (err error) {
 		return err
 	}
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActionPlans, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActionPlans, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -55,8 +55,8 @@ func (m *Migrator) migrateCurrentTPactionplans() (err error) {
 
 func (m *Migrator) migrateTPactionplans() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_action_triggers.go b/migrator/tp_action_triggers.go
index 50f71c1f4..99cee4191 100644
--- a/migrator/tp_action_triggers.go
+++ b/migrator/tp_action_triggers.go
@@ -31,7 +31,7 @@ func (m *Migrator) migrateCurrentTPactiontriggers() (err error) {
 		return err
 	}
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActionTriggers, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActionTriggers, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -55,8 +55,8 @@ func (m *Migrator) migrateCurrentTPactiontriggers() (err error) {
 
 func (m *Migrator) migrateTPactiontriggers() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_actions.go b/migrator/tp_actions.go
index f7fd2e6a3..ba720943a 100644
--- a/migrator/tp_actions.go
+++ b/migrator/tp_actions.go
@@ -31,7 +31,7 @@ func (m *Migrator) migrateCurrentTPactions() (err error) {
 		return err
 	}
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActions, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPActions, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -55,8 +55,8 @@ func (m *Migrator) migrateCurrentTPactions() (err error) {
 
 func (m *Migrator) migrateTPactions() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_aliases.go b/migrator/tp_aliases.go
index d46f7968d..c4c4f5e2e 100644
--- a/migrator/tp_aliases.go
+++ b/migrator/tp_aliases.go
@@ -31,13 +31,16 @@ func (m *Migrator) migrateCurrentTPaliases() (err error) {
 		return err
 	}
 	for _, tpid := range tpids {
-		dest, err := m.InStorDB().GetTPAliases(&utils.TPAliases{TPid: tpid})
+		dests, err := m.InStorDB().GetTPAliases(&utils.TPAliases{TPid: tpid})
 		if err != nil {
 			return err
 		}
-		if dest != nil {
+		for _, dest := range dests {
+			dest.TPid = tpid
+		}
+		if dests != nil {
 			if m.dryRun != true {
-				if err := m.OutStorDB().SetTPAliases(dest); err != nil {
+				if err := m.OutStorDB().SetTPAliases(dests); err != nil {
 					return err
 				}
 				m.stats[utils.TpAliases] += 1
@@ -50,8 +53,8 @@ func (m *Migrator) migrateCurrentTPaliases() (err error) {
 
 func (m *Migrator) migrateTPaliases() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_cdr_stats.go b/migrator/tp_cdr_stats.go
index c9219155b..6e456965c 100644
--- a/migrator/tp_cdr_stats.go
+++ b/migrator/tp_cdr_stats.go
@@ -31,7 +31,7 @@ func (m *Migrator) migrateCurrentTPcdrstats() (err error) {
 		return err
 	}
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPCdrStats, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPCdrStats, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -55,8 +55,8 @@ func (m *Migrator) migrateCurrentTPcdrstats() (err error) {
 
 func (m *Migrator) migrateTPcdrstats() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_derived_chargers.go b/migrator/tp_derived_chargers.go
index fce6d26c5..082842749 100644
--- a/migrator/tp_derived_chargers.go
+++ b/migrator/tp_derived_chargers.go
@@ -51,8 +51,8 @@ func (m *Migrator) migrateCurrentTPderivedchargers() (err error) {
 
 func (m *Migrator) migrateTPderivedchargers() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_destination_rates.go b/migrator/tp_destination_rates.go
index 772046317..2bb661a14 100644
--- a/migrator/tp_destination_rates.go
+++ b/migrator/tp_destination_rates.go
@@ -26,13 +26,12 @@ import (
 )
 
 func (m *Migrator) migrateCurrentTPdestinationrates() (err error) {
-	tpids, err := m.InStorDB().GetTpIds(utils.TBLTPRatingPlans)
+	tpids, err := m.InStorDB().GetTpIds(utils.TBLTPDestinationRates)
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPRatingPlans, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPDestinationRates, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -56,8 +55,8 @@ func (m *Migrator) migrateCurrentTPdestinationrates() (err error) {
 
 func (m *Migrator) migrateTPdestinationrates() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_destinations.go b/migrator/tp_destinations.go
index 563073228..308e61d9a 100644
--- a/migrator/tp_destinations.go
+++ b/migrator/tp_destinations.go
@@ -30,9 +30,8 @@ func (m *Migrator) migrateCurrentTPDestinations() (err error) {
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPDestinations, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPDestinations, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -56,8 +55,8 @@ func (m *Migrator) migrateCurrentTPDestinations() (err error) {
 
 func (m *Migrator) migrateTPDestinations() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_filters.go b/migrator/tp_filters.go
index 7d9564441..f563fb3f8 100644
--- a/migrator/tp_filters.go
+++ b/migrator/tp_filters.go
@@ -32,7 +32,7 @@ func (m *Migrator) migrateCurrentTPfilters() (err error) {
 	}
 
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPFilters, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPFilters, utils.TPDistinctIds{"id"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -56,8 +56,8 @@ func (m *Migrator) migrateCurrentTPfilters() (err error) {
 
 func (m *Migrator) migrateTPfilters() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_lcrs.go b/migrator/tp_lcr_rules.go
similarity index 86%
rename from migrator/tp_lcrs.go
rename to migrator/tp_lcr_rules.go
index 49360bdb2..407c9aa54 100644
--- a/migrator/tp_lcrs.go
+++ b/migrator/tp_lcr_rules.go
@@ -25,12 +25,11 @@ import (
 	"github.com/cgrates/cgrates/utils"
 )
 
-func (m *Migrator) migrateCurrentTPlcrs() (err error) {
+func (m *Migrator) migrateCurrentTpLCRRules() (err error) {
 	tpids, err := m.InStorDB().GetTpIds(utils.TBLTPLcrs)
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
 		dest, err := m.InStorDB().GetTPLCRs(&utils.TPLcrRules{TPid: tpid})
 		if err != nil {
@@ -48,10 +47,10 @@ func (m *Migrator) migrateCurrentTPlcrs() (err error) {
 	return
 }
 
-func (m *Migrator) migrateTPlcrs() (err error) {
+func (m *Migrator) migrateTpLCRRules() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
@@ -68,7 +67,7 @@ func (m *Migrator) migrateTPlcrs() (err error) {
 		if m.sameStorDB {
 			return
 		}
-		if err := m.migrateCurrentTPcdrstats(); err != nil {
+		if err := m.migrateCurrentTpLCRRules(); err != nil {
 			return err
 		}
 		return
diff --git a/migrator/tp_rates.go b/migrator/tp_rates.go
index 098826e43..03a14b705 100644
--- a/migrator/tp_rates.go
+++ b/migrator/tp_rates.go
@@ -26,13 +26,12 @@ import (
 )
 
 func (m *Migrator) migrateCurrentTPrates() (err error) {
-	tpids, err := m.InStorDB().GetTpIds(utils.TBLTPDestinations)
+	tpids, err := m.InStorDB().GetTpIds(utils.TBLTPRates)
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPDestinations, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPRates, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -57,8 +56,8 @@ func (m *Migrator) migrateCurrentTPrates() (err error) {
 
 func (m *Migrator) migrateTPrates() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_rating_plans.go b/migrator/tp_rating_plans.go
index 2c022a253..d029abbc4 100644
--- a/migrator/tp_rating_plans.go
+++ b/migrator/tp_rating_plans.go
@@ -30,24 +30,24 @@ func (m *Migrator) migrateCurrentTPratingplans() (err error) {
 	if err != nil {
 		return err
 	}
-
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPRatingPlans, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPRatingPlans, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
-		for _, id := range ids {
-
-			rps, err := m.InStorDB().GetTPRatingPlans(tpid, id, nil)
-			if err != nil {
-				return err
-			}
-			if rps != nil {
-				if m.dryRun != true {
-					if err := m.InStorDB().SetTPRatingPlans(rps); err != nil {
-						return err
+		if len(ids) != 0 {
+			for _, id := range ids {
+				rps, err := m.InStorDB().GetTPRatingPlans(tpid, id, nil)
+				if err != nil {
+					return err
+				}
+				if rps != nil {
+					if m.dryRun != true {
+						if err := m.OutStorDB().SetTPRatingPlans(rps); err != nil {
+							return err
+						}
+						m.stats[utils.TpRatingPlans] += 1
 					}
-					m.stats[utils.TpRatingPlans] += 1
 				}
 			}
 		}
@@ -57,8 +57,8 @@ func (m *Migrator) migrateCurrentTPratingplans() (err error) {
 
 func (m *Migrator) migrateTPratingplans() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_rating_profiles.go b/migrator/tp_rating_profiles.go
index d2c510469..cd0f729a6 100644
--- a/migrator/tp_rating_profiles.go
+++ b/migrator/tp_rating_profiles.go
@@ -51,8 +51,8 @@ func (m *Migrator) migrateCurrentTPratingprofiles() (err error) {
 
 func (m *Migrator) migrateTPratingprofiles() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_resources.go b/migrator/tp_resources.go
index a9b647f4c..db31417b8 100644
--- a/migrator/tp_resources.go
+++ b/migrator/tp_resources.go
@@ -32,7 +32,7 @@ func (m *Migrator) migrateCurrentTPresources() (err error) {
 	}
 
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPResources, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPResources, utils.TPDistinctIds{"id"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -57,8 +57,8 @@ func (m *Migrator) migrateCurrentTPresources() (err error) {
 
 func (m *Migrator) migrateTPresources() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_shared_groups.go b/migrator/tp_shared_groups.go
index e9697b781..8f0c4c9f3 100644
--- a/migrator/tp_shared_groups.go
+++ b/migrator/tp_shared_groups.go
@@ -32,7 +32,7 @@ func (m *Migrator) migrateCurrentTPsharedgroups() (err error) {
 	}
 
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPSharedGroups, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPSharedGroups, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -57,8 +57,8 @@ func (m *Migrator) migrateCurrentTPsharedgroups() (err error) {
 
 func (m *Migrator) migrateTPsharedgroups() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_stats.go b/migrator/tp_stats.go
index 9f0dfad16..4f99d7089 100644
--- a/migrator/tp_stats.go
+++ b/migrator/tp_stats.go
@@ -32,7 +32,7 @@ func (m *Migrator) migrateCurrentTPstats() (err error) {
 	}
 
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPStats, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPStats, utils.TPDistinctIds{"id"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -57,8 +57,8 @@ func (m *Migrator) migrateCurrentTPstats() (err error) {
 
 func (m *Migrator) migrateTPstats() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_suppliers.go b/migrator/tp_suppliers.go
index 5455dbeea..a8b69d6bd 100644
--- a/migrator/tp_suppliers.go
+++ b/migrator/tp_suppliers.go
@@ -57,8 +57,8 @@ func (m *Migrator) migrateCurrentTPSuppliers() (err error) {
 
 func (m *Migrator) migrateTPSuppliers() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLTPSuppliers)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLTPSuppliers)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_thresholds.go b/migrator/tp_thresholds.go
index d06eb976c..7c982e15a 100644
--- a/migrator/tp_thresholds.go
+++ b/migrator/tp_thresholds.go
@@ -32,7 +32,7 @@ func (m *Migrator) migrateCurrentTPthresholds() (err error) {
 	}
 
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPThresholds, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPThresholds, utils.TPDistinctIds{"id"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -57,8 +57,8 @@ func (m *Migrator) migrateCurrentTPthresholds() (err error) {
 
 func (m *Migrator) migrateTPthresholds() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_timings.go b/migrator/tp_timings.go
index 330454152..4b8ee5113 100644
--- a/migrator/tp_timings.go
+++ b/migrator/tp_timings.go
@@ -32,7 +32,7 @@ func (m *Migrator) migrateCurrentTPTiming() (err error) {
 	}
 
 	for _, tpid := range tpids {
-		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPTimings, utils.TPDistinctIds{}, map[string]string{}, nil)
+		ids, err := m.InStorDB().GetTpTableIds(tpid, utils.TBLTPTimings, utils.TPDistinctIds{"tag"}, map[string]string{}, nil)
 		if err != nil {
 			return err
 		}
@@ -57,8 +57,8 @@ func (m *Migrator) migrateCurrentTPTiming() (err error) {
 
 func (m *Migrator) migrateTpTimings() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/migrator/tp_users.go b/migrator/tp_users.go
index a7a0b470b..ed8fd8416 100644
--- a/migrator/tp_users.go
+++ b/migrator/tp_users.go
@@ -51,8 +51,8 @@ func (m *Migrator) migrateCurrentTPusers() (err error) {
 
 func (m *Migrator) migrateTPusers() (err error) {
 	var vrs engine.Versions
-	current := engine.CurrentDataDBVersions()
-	vrs, err = m.dmOut.DataDB().GetVersions(utils.TBLVersions)
+	current := engine.CurrentStorDBVersions()
+	vrs, err = m.OutStorDB().GetVersions(utils.TBLVersions)
 	if err != nil {
 		return utils.NewCGRError(utils.Migrator,
 			utils.ServerErrorCaps,
diff --git a/utils/consts.go b/utils/consts.go
index 457b6ef43..be8f2290b 100755
--- a/utils/consts.go
+++ b/utils/consts.go
@@ -512,7 +512,7 @@ const (
 	TpFilters                       = "TpFilters"
 	TpDestinationRates              = "TpDestinationRates"
 	TpActionTriggers                = "TpActionTriggers"
-	TpAccountActions                = "TpAccountActions"
+	TpAccountActionsV               = "TpAccountActions"
 	TpActionPlans                   = "TpActionPlans"
 	TpActions                       = "TpActions"
 	TpDerivedCharges                = "TpDerivedCharges"
@@ -562,14 +562,14 @@ const (
 	MetaSubscribers                 = "*Subscribers"
 	MetaDerivedChargersV            = "*DerivedChargers"
 	MetaTpRatingPlans               = "*TpRatingPlans"
-	MetaTpLcrs                      = "*TpLcrs"
+	MetaTpLCRRules                  = "*TpLcrs"
 	MetaTpFilters                   = "*TpFilters"
 	MetaTpDestinationRates          = "*TpDestinationRates"
 	MetaTpActionTriggers            = "*TpActionTriggers"
 	MetaTpAccountActions            = "*TpAccountActions"
 	MetaTpActionPlans               = "*TpActionPlans"
 	MetaTpActions                   = "*TpActions"
-	MetaTpDerivedCharges            = "*TpDerivedCharges"
+	MetaTpDerivedChargers           = "*TpDerivedCharges"
 	MetaTpThresholds                = "*TpThresholds"
 	MetaTpSuppliers                 = "*TpSuppliers"
 	MetaTpStats                     = "*TpStats"
@@ -584,7 +584,6 @@ const (
 	MetaTpDerivedChargersV          = "*TpDerivedChargers"
 	MetaTpCdrStats                  = "*TpCdrStats"
 	MetaTpDestinations              = "*TpDestinations"
-	MetaTpLCR                       = "*TpLCR"
 	MetaTpRatingPlan                = "*TpRatingPlan"
 	MetaTpRatingProfile             = "*TpRatingProfile"
 	MetaStorDB                      = "*stordb"