Risk-Based Address Masking

import de.ubs.xdm3.batch.modification.MappingTableUtils
import de.ubs.xdm3.batch.modification.ModificationException
import de.ubs.xdm3.batch.modification.CompositeKey
import de.ubs.xdm3.batch.modification.HashUtils

import groovy.sql.Sql

xdmLookupTable = 'riskByAddresses'

// idx columns to mask
gk = ctx.indexOf('gk')
zone = ctx.indexOf('zone')
sgk = ctx.indexOf('sgk')
ems = ctx.indexOf('ems')
slz = ctx.indexOf('slz')
ldv = ctx.indexOf('ldv')

zip = ctx.indexOf('zip')
city = ctx.indexOf('city')
street = ctx.indexOf('street')
housenumber = ctx.indexOf('housenumber')

/*
 * This function is called once before the processing starts.
 * The method is called once per table.
 */
def init() {
}

/*
 * This function should modify the row that is provided by the dataArray.
 * The method is called for each single row of the table.
 */
def apply() {
    def sql = Sql.newInstance(risklookupTable)

    // Check 1: each address must have data for all possible risk classes
    def fields_str = ['gk', 'zone', 'sgk', 'ems', 'slz', 'ldv']
    def fields_idx = [gk, zone, sgk, ems, slz, ldv]

    if (fields_idx.any { !data[it] }) {
        // statement to get identical address
        // update in case of different data structure
        def stmt_risk = """
            SELECT gk, zone, sgk, ems, slz, ldv
            FROM ${xdmLookupTable}
            WHERE zip = ?
              AND city = ?
              AND street = ?
              AND housenumber = ?
         """

        def result_address = sql.rows(stmt_risk, [
            data[zip],
            data[city],
            data[street],
            data[housenumber]
        ])

        if (!result_address) {
            throw new ModificationException("No data for this address in lookup table")
        } else {
            result_address.each { row ->
                for (int i = 0; i < fields_str.size(); i++) {
                    def f = fields_str[i]
                    def f2 = fields_idx[i]

                    if (!data[f2]) {
                        data[f2] = row[i]
                    }
                }
            }
        }
    }

    // Check 2: get an address from lookup table that has identical risk classes
    // update statement in case of different data structure
    def stmt_getAddress = """
        SELECT zip, city, street, housenumber
        FROM ${xdmLookupTable}
        WHERE gk = ?
          AND zone = ?
          AND sgk = ?
          AND ems = ?
          AND slz = ?
          AND ldv = ?
       """

    def result_byrisk = sql.rows(stmt_getAddress, [
        data[gk],
        data[zone],
        data[sgk],
        data[ems],
        data[slz],
        data[ldv]
    ])

    // no address found -> throw exception
    if (!result_byrisk || result_byrisk.size() <= 1) {
        throw new ModificationException("No data available")
    }

    result_byrisk.each { row -> println(row) }

    def key = "${data[zip]?.toString()?.trim()}${data[city]?.toString()?.trim()}${data[street]?.toString()?.trim()}${data[housenumber]?.toString()?.trim()}"
    def seed = HashUtils.hashStringLikeInt(key)
    def new_data = null

    for (int i = 0; i < result_byrisk.size(); i++) {
        def index = Math.floorMod(seed + i, result_byrisk.size())
        def candidate = result_byrisk[index]

        // normalize data
        def original = [
            data[zip]?.toString()?.trim(),
            data[city]?.toString()?.trim(),
            data[street]?.toString()?.trim(),
            data[housenumber]?.toString()?.trim()
        ]

        def candidateAddress = [
            candidate[zip]?.toString()?.trim(),
            candidate[city]?.toString()?.trim(),
            candidate[street]?.toString()?.trim(),
            candidate[housenumber]?.toString()?.trim()
        ]

        // use only in case of other data
        if (candidateAddress != original) {
            new_data = candidate
            break
        }
    }

    // update data
    data[zip] = new_data[0]
    data[city] = new_data[1]
    data[street] = new_data[2]
    data[housenumber] = new_data[3]

    return true
}

def close() {
}