forked from deblan/database-anonymizer
278 lines
6.1 KiB
Go
278 lines
6.1 KiB
Go
package app
|
|
|
|
import (
|
|
"database/sql"
|
|
"errors"
|
|
"fmt"
|
|
|
|
"strings"
|
|
|
|
"github.com/schollz/progressbar/v3"
|
|
|
|
"gitnet.fr/deblan/database-anonymizer/config"
|
|
"gitnet.fr/deblan/database-anonymizer/data"
|
|
"gitnet.fr/deblan/database-anonymizer/database"
|
|
"gitnet.fr/deblan/database-anonymizer/faker"
|
|
"gitnet.fr/deblan/database-anonymizer/logger"
|
|
)
|
|
|
|
type App struct {
|
|
Db *sql.DB
|
|
DbConfig config.DatabaseConfig
|
|
FakeManager faker.FakeManager
|
|
}
|
|
|
|
func (a *App) Run(
|
|
db *sql.DB,
|
|
c config.SchemaConfig,
|
|
fakeManager faker.FakeManager,
|
|
dbc config.DatabaseConfig,
|
|
) error {
|
|
a.Db = db
|
|
a.FakeManager = fakeManager
|
|
a.DbConfig = dbc
|
|
|
|
for _, data := range c.Rules.Actions {
|
|
err := a.DoAction(data, c.Rules.Columns, c.Rules.Generators)
|
|
|
|
logger.LogFatalExitIf(err)
|
|
}
|
|
|
|
_ = db
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a *App) TruncateTable(c config.SchemaConfigAction) error {
|
|
bar := progressbar.Default(1, fmt.Sprintf("Truncating %s...", c.Table))
|
|
|
|
if c.Query == "" {
|
|
_, err := a.Db.Exec(fmt.Sprintf("TRUNCATE %s", database.EscapeTable(a.DbConfig.Type, c.Table)))
|
|
|
|
bar.Add(1)
|
|
|
|
return err
|
|
}
|
|
|
|
query := a.CreateSelectQuery(c)
|
|
rows := database.GetRows(a.Db, query, c.Table, a.DbConfig.Type)
|
|
var scan any
|
|
|
|
bar.ChangeMax(len(rows))
|
|
|
|
for _, row := range rows {
|
|
pkeys := []string{}
|
|
values := make(map[int]string)
|
|
|
|
for _, col := range c.PrimaryKey {
|
|
if !row[col].IsString || row[col].IsNull {
|
|
value := row[col]
|
|
pkeys = append(pkeys, fmt.Sprintf("%s=%s", col, value.FinalValue()))
|
|
} else {
|
|
pkeys = append(pkeys, database.GetNamedParameter(a.DbConfig.Type, col, len(values)+1))
|
|
values[len(values)+1] = row[col].Value
|
|
}
|
|
}
|
|
|
|
sql := fmt.Sprintf(
|
|
"DELETE FROM %s WHERE %s",
|
|
database.EscapeTable(a.DbConfig.Type, c.Table),
|
|
strings.Join(pkeys, " AND "),
|
|
)
|
|
|
|
var args []any
|
|
if len(values) > 0 {
|
|
for i := 1; i <= len(values); i++ {
|
|
args = append(args, values[i])
|
|
}
|
|
}
|
|
|
|
a.Db.QueryRow(sql, args...).Scan(&scan)
|
|
|
|
bar.Add(1)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a *App) UpdateRows(c config.SchemaConfigAction, globalColumns map[string]string, generators map[string][]string) error {
|
|
query := a.CreateSelectQuery(c)
|
|
rows := database.GetRows(a.Db, query, c.Table, a.DbConfig.Type)
|
|
var scan any
|
|
|
|
bar := progressbar.Default(int64(len(rows)))
|
|
bar.Describe(fmt.Sprintf("Updating %s...", c.Table))
|
|
|
|
for key, row := range rows {
|
|
if len(c.VirtualColumns) > 0 {
|
|
for col, faker := range c.VirtualColumns {
|
|
rows[key][col] = data.Data{
|
|
Value: "",
|
|
Faker: faker,
|
|
IsVirtual: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(c.Columns) > 0 {
|
|
for col, faker := range c.Columns {
|
|
r := row[col]
|
|
r.Faker = faker
|
|
rows[key][col] = r
|
|
}
|
|
}
|
|
|
|
if len(globalColumns) > 0 {
|
|
for col, faker := range globalColumns {
|
|
if value, exists := row[col]; exists {
|
|
if value.Faker == "" {
|
|
value.Faker = faker
|
|
rows[key][col] = value
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if len(generators) > 0 {
|
|
for faker, columns := range generators {
|
|
for _, col := range columns {
|
|
if value, exists := row[col]; exists {
|
|
if value.Faker == "" {
|
|
value.Faker = faker
|
|
rows[key][col] = value
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, col := range c.PrimaryKey {
|
|
value := row[col]
|
|
value.IsPrimaryKey = true
|
|
rows[key][col] = value
|
|
}
|
|
|
|
v, err := a.UpdateRow(rows[key])
|
|
|
|
logger.LogFatalExitIf(err)
|
|
|
|
rows[key] = v
|
|
}
|
|
|
|
for _, row := range rows {
|
|
updates := []string{}
|
|
pkeys := []string{}
|
|
values := make(map[int]string)
|
|
|
|
for col, value := range row {
|
|
if value.IsUpdated && !value.IsVirtual {
|
|
if value.IsString && !value.IsNull {
|
|
updates = append(updates, database.GetNamedParameter(a.DbConfig.Type, col, len(values)+1))
|
|
values[len(values)+1] = value.FinalValue()
|
|
} else {
|
|
updates = append(updates, fmt.Sprintf("%s=%s", col, value.FinalValue()))
|
|
}
|
|
}
|
|
}
|
|
|
|
for _, col := range c.PrimaryKey {
|
|
value := row[col]
|
|
|
|
if !value.IsString || value.IsNull {
|
|
pkeys = append(pkeys, fmt.Sprintf("%s=%s", col, value.FinalValue()))
|
|
} else {
|
|
pkeys = append(pkeys, database.GetNamedParameter(a.DbConfig.Type, col, len(values)+1))
|
|
values[len(values)+1] = value.FinalValue()
|
|
}
|
|
}
|
|
|
|
if len(updates) > 0 {
|
|
sql := fmt.Sprintf(
|
|
"UPDATE %s SET %s WHERE %s",
|
|
database.EscapeTable(a.DbConfig.Type, c.Table),
|
|
strings.Join(updates, ", "),
|
|
strings.Join(pkeys, " AND "),
|
|
)
|
|
|
|
var args []any
|
|
if len(values) > 0 {
|
|
for i := 1; i <= len(values); i++ {
|
|
args = append(args, values[i])
|
|
}
|
|
}
|
|
|
|
err := a.Db.QueryRow(sql, args...).Scan(&scan)
|
|
|
|
if err.Error() != "" && err.Error() != "sql: no rows in result set" {
|
|
logger.LogFatalExitIf(err)
|
|
}
|
|
}
|
|
|
|
bar.Add(1)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (a *App) CreateSelectQuery(c config.SchemaConfigAction) string {
|
|
if c.Query != "" {
|
|
return c.Query
|
|
}
|
|
|
|
return fmt.Sprintf("SELECT * FROM %s", database.EscapeTable(a.DbConfig.Type, c.Table))
|
|
}
|
|
|
|
func (a *App) DoAction(c config.SchemaConfigAction, globalColumns map[string]string, generators map[string][]string) error {
|
|
if c.Table == "" {
|
|
return errors.New("Table must be defined")
|
|
}
|
|
|
|
c.InitPrimaryKey()
|
|
|
|
if c.Truncate {
|
|
return a.TruncateTable(c)
|
|
}
|
|
|
|
return a.UpdateRows(c, globalColumns, generators)
|
|
}
|
|
|
|
func (a *App) UpdateRow(row map[string]data.Data) (map[string]data.Data, error) {
|
|
for key, value := range row {
|
|
if value.IsVirtual && !value.IsTwigExpression() {
|
|
if !a.FakeManager.IsValidFaker(value.Faker) {
|
|
return row, errors.New(fmt.Sprintf("\"%s\" is not a valid faker", value.Faker))
|
|
}
|
|
|
|
value.Update(row, a.FakeManager)
|
|
row[key] = value
|
|
}
|
|
}
|
|
|
|
for key, value := range row {
|
|
if value.IsVirtual && value.IsTwigExpression() {
|
|
value.Update(row, a.FakeManager)
|
|
row[key] = value
|
|
}
|
|
}
|
|
|
|
for key, value := range row {
|
|
if !value.IsVirtual && !value.IsTwigExpression() {
|
|
if !a.FakeManager.IsValidFaker(value.Faker) {
|
|
return row, errors.New(fmt.Sprintf("\"%s\" is not a valid faker", value.Faker))
|
|
}
|
|
|
|
value.Update(row, a.FakeManager)
|
|
row[key] = value
|
|
}
|
|
}
|
|
|
|
for key, value := range row {
|
|
if !value.IsVirtual && value.IsTwigExpression() {
|
|
value.Update(row, a.FakeManager)
|
|
row[key] = value
|
|
}
|
|
}
|
|
|
|
return row, nil
|
|
}
|