Scripts

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

def mappingTableUtils = null;
def TABLE_NAME = null;
def country = null;
def map = null;
def numberOfValues = 0;

void init() {
    // Creating an instance of MappingTableUtils using the provided mapping table container, which was defined with the variable name 'mtc'
    mappingTableUtils = new MappingTableUtils(lookupTable);
    TABLE_NAME = "LAST_NAMES";
    country = "EN";

    // Retrieves the count of entries in the "LAST_NAMES" table for the column "KEY_01" (country)
    map = mappingTableUtils.count(TABLE_NAME, "KEY_01");

    // Retrieves the number of entries fpr the current country
    numberOfValues = map.get(new CompositeKey(country))
}

def generateAttribute(EntityInstance entity, FieldDefinition field) {
    def rand = (Math.random() * 1000000000) as int;
    def hash = HashUtils.hashInt(rand);
    def row = (Integer) (hash % numberOfValues) + 1;

    // Fetches the value from the table based on the row ID and the country
    return mappingTableUtils.get(TABLE_NAME, row, country)[0];
}

def generateAttribute(EntityInstance entity, FieldDefinition field) {
     def firstName = entity.attributes['first_name']
     def lastName = entity.attributes['last_name']
     return firstName.toLowerCase() + "." + lastName.toLowerCase() + "@mycompany.de"
}

int getMatchScore(FieldDefinition attribute, EntityGeneratorDefinition entityGeneratorDefinition, Map parameters) {
     if(attribute.name.toLowerCase() == "email") {
         return 100;
     }
     return 0;
}

['E' + data['emp_no'].longValue().toString().padLeft(6, '0')].toArray();

['E' + java.lang.String.format("%06d", data['emp_no'].longValue())]

var empNoStr = data['emp_no'].longValue().toString()
[empNoStr.substring(0, 2), empNoStr.substring(2)].toArray()

var empNoStr = data['emp_no'].longValue().toString()
var array = [empNoStr.substring(0, 2), empNoStr.substring(2)]
array

meta['copy_manager'].updatable = false;
dataShop.copy_manager = false;

meta['copy_manager'].updatable = false;
dataShop.copy_manager = false;

var options = meta['employees'].options
var index = options.find { e -> e.value == '10001' }
options.remove(index)

var index = 0;
var options = meta['employees'].options
for(i in options) {
    if(options[i].value == '10001') {
        index = i;
        break;
    }
}
options.remove(index)

endpoints = [
    find: [
        path: "/department/1/employee/1",
    ],
    list: [
        path: "department/1/employee",
        paging: [
            pageParameter: "page",
            sizeParameter: "size",
            pageSize: 20
        ]
    ]
]

// The attributes variable assigned the attributes of the webservice response to the domain entity.
attributes = [
    [
        name:   "Name",
        description: "The name of the employee",
        index:  false,
        key:    false,
        path:   "name",
        type:   "STRING"
    ],
    [
        name:   "Email",
        description: "The email address of the employee",
        index:  false,
        key:    false,
        path:   "email",
        type:   "STRING"
    ],
    [
        name:   "Hire Date",
        description: "The date the employee was hired",
        index:  false,
        key:    false,
        path:   "hireDate",
        type:   "TIMESTAMP"
    ],
    [
        name:   "department",
        description: "The department the employee belongs to",
        index:  false,
        key:    false,
        path:   "department",
        type:   "STRING"
    ],
    [
        name:   "Self",
        description: "The link to the employee",
        index:  false,
        key:    true,
        path:   "_links.self.herf",
        type:   "STRING"
    ]
];

def displayName(Map<String, String> attributes) {
    return attributes.getOrDefault("name", "UNKNOWN")
}

def preProcessResponse(response) {
  // Drop the first line
  return response.split('\n').drop(1).join('\n')
}

def entityGenerationConfiguration = [:];

void init() {
    entityGenerationConfiguration = [
        "gender": processorFactory.createAttributeGenerator(processor, "genderGenerator"),
        "first_name": processorFactory.createAttributeGenerator(processor, "nameGenerator", [nameType: "FIRST_NAMES"]),
        "last_name": processorFactory.createAttributeGenerator(processor, "nameGenerator", [nameType: "LAST_NAMES"]),
        "birth_date": processorFactory.createAttributeGenerator(processor, "dateGenerator", [minValue: "1964-01-01", maxValue: "2007-01-01"]),
        "emp_no": processorFactory.createAttributeGenerator(processor, "numberGenerator", [initialValue: parameters.empNo]),
    ];
}

EntityInstance generateEntity() {
    return buildEntity(entityGenerationConfiguration);
}

  EntityInstance generateEntity() {
    return llm(1, "Generate employees.", ["first_name":"Generate spanish first name",
                                           "last_name":"Generate swedish last name",
                                           "emp_no":"Generate employee number between 1 and 1000000",
                                           "birth_date":"Generate birth date between 1964-01-01 and 2007-01-01"
                                           ]);
  }

def void apply(Map<String,Object> data) {
    def fn = data.get("first_name")
    def ln = data.get("last_name")
    data.put("first_name", fn[0] + "***")
    data.put("last_name",  ln[0] + "***")
    data.put("email", "${fn[0]}${ln[0]}***@example.com")
}

def void apply(Map<String,Object> data) {
    def items = data.get("items")
    def output = items.replaceAll(/"qty"\s*:\s*\d+/, '"qty": 0')
    data.put("items", output)
}

void generateScenario() {
    def employeeGenerator = processorFactory.createEntityGenerator(processor, "employee", [empNo: parameters.empNo]);
    def employee = employeeGenerator.generateEntity();
    flush(employee);

    def salaryGenerator = processorFactory.createEntityGenerator(processor, "salary", [emp: employee]);
    def titleGenerator = processorFactory.createEntityGenerator(processor, "title", [emp: employee]);
    def salary = salaryGenerator.generateEntity();
    def title = titleGenerator.generateEntity();
    flush(salary);
    flush(title);
}

if(user.authorities.contains('PURCHASER')) {
    object.csvDelimiter = ';';
    object.fileType = 'CSV';
}

if(user.authorities.indexOf('PURCHASER') != -1) {
    object.csvDelimiter = ';';
    object.fileType = 'CSV';
}

import jakarta.mail.*
import jakarta.mail.internet.*;

def from = user.email
def to = "approver@example.com"
def subject = "Approve data shop ${object.dataShop.displayName}"
def content = """
    The user '${user.name}' requested an execution for data shop '${object.dataShop.displayName}'.
    Please review this request here: https://xdm.example.com/gen/res${object.contextPath}
    """

def smtpHost = "example.com"
def smtpPort = 587
def smtpCredential = api.credentials.find{c -> c.displayName == 'SMTP User'}

// Setup internal properties
def props = [
    "mail.smtp.user": smtpCredential.user,
    "mail.smtp.host": smtpHost,
    "mail.smtp.port": smtpPort,
    "mail.smtp.starttls.enable": true,
    "mail.smtp.socketFactory.class": "javax.net.ssl.SSLSocketFactory",
    "mail.smtp.ssl.trust": smtpHost
]

// Setup the message.
def message = new MimeMessage(Session.getDefaultInstance(new Properties(props)))
message.setFrom(new InternetAddress(from))
message.addRecipients(Message.RecipientType.TO, new InternetAddress(to))
message.setSubject(subject)
message.setContent(content.toString(), "text/plain")

// Send the mail.
Transport.send(message, smtpCredential.user, smtpCredential.password)

println("Original export")
println('-' * 80)
objects.each{it ->
    printExportData(it, 0)
    println()
}

// Sort export objects by type and attribute display names
def sortedObjects = objects.sort{a,b -> a.type <=> b.type ?: a.attributes.displayName <=> b.attributes.displayName}
sortedObjects.each{obj ->
    if (obj.children) {
        sortChildren(obj)
    }
}

println("Sorted export")
println('-' * 80)
sortedObjects.each{it ->
    printExportData(it, 0)
    println()
}

def printExportData(entity, indentLevel) {
    def displayName = entity.attributes.displayName ?: "n/a"
    def indent = '  ' * indentLevel
    ++indentLevel;
    def message = "${displayName}, ${entity.type}"
    println("${indent}${message}")
    if (entity.children) {
        entity.children.each{child -> printExportData(child, indentLevel)}
    }
}

def sortChildren(entity) {
    entity.children = entity.children.sort{ a,b ->
        def aName = a.attributes.displayName ?: ""
        def bName = b.attributes.displayName ?: ""
        a.type <=> b.type ?: aName <=> bName
    }
    entity.children.each{child ->
        if (child.children) {
            sortChildren(child)
        }
    }
}

// Filter objects by type, variation, and attribute value
def filteredObjects  = objects.findAll{ obj->
    obj.type == "TaskTemplate" &&
    obj.variation == "subset-task-template" &&
    obj.attributes.executionRetentionPeriod == "P5D"
}

// Change the attribute value
filteredObjects.each{obj ->
    obj.attributes.executionRetentionPeriod = "-1"
    println("Attribute execution retention period of type '${obj.type}' with the name '${obj.attributes.displayName}' has been changed, new value: ${obj.attributes.executionRetentionPeriod}")
}

String init(EntityDefinition definition) {
    // Write the header line to the file
    def header = definition.fields.collect { field -> field.name }.join(';')
    return header + '\n';
}

String process(List<EntityInstance> instances, EntityDefinition definition) {
    // Generate one or more lines for the entity instance
    return instances.collect { instance ->
        return definition.fields
            .collect { field -> instance.attributes[field.name] }
            .join(';')
    }.join('\n') + '\n'
}

def login() {
  payload = [
    username: webservice.credential.user,
    password: webservice.credential.password
  ]
  response = post(webservice.baseUrl + '/foobar/login', payload)
  return response.getHeader('Token')
}