custom_schema_types.config

/**
* This custom schema namespace implements a custom type for checking input BAMs for call-gSNP
*/
custom_schema_types {
    allowed_input_types = [
        'BAM'
    ]
    allowed_bam_types = [
        'normal',
        'tumor'
    ]
    allowed_resource_types = [
        'memory',
        'cpus'
    ]

    /**
    * Check that input types are in allowed list
    */
    check_input_type_keys = { List given, String name, List choices=custom_schema_types.allowed_input_types ->
        for (elem in given) {
            if (!(elem in choices)) {
                throw new Exception("Invalid paramter ${name}. Valid types: ${choices}.")
            }
        }
    }

    /**
    *   Check if input is a String or GString
    */
    is_string = { val ->
        return (val in String || val in GString)
    }

    /**
    * Check if given input is a Namespace
    */
    check_if_namespace = { val, String name ->
        if (!(val in Map)) {
            throw new Exception("${name} should be a Namespace, not ${val.getClass()}.")
        }
    }

    /**
    * Check if given input is a list
    */
    check_if_list = { val, String name ->
        if (!(val in List || val in Set)) {
            throw new Exception("${name} should be a List, not ${val.getClass()}.")
        }
    }

    /**
    *   Check if given input is a number
    */
    check_if_number = { val, String name ->
        if (!(val in Integer || val in Float)) {
            throw new Exception("${name} should be an Integer or Float, not ${val.getClass()}")
        }
    }

    /**
    *   Check if given input is valid process list
    */
    check_if_process_list = { val, String name ->
        if (custom_schema_types.is_string(val)) {
            if (val.isEmpty()) {
                throw new Exception("Empty string specified for ${name}. Please provide valid input.")
            }
        } else {
            try {
                custom_schema_types.check_if_list(val, name)
            } catch(Exception e) {
                throw new Exception("${name} should be either a string or a list. Please provide valid input.")
            }
        }
    }

    /**
    * Check that input is namespace of expected types
    */
    check_input_namespace = { Map options, String name, Map properties ->
        // Check parameters keys
        custom_schema_types.check_if_namespace(options[name], name)
        def given_keys = options[name].keySet() as ArrayList
        custom_schema_types.check_input_type_keys(given_keys, name)

        options[name].each { entry ->
            def entry_as_map = [:]
            entry_as_map[entry.key] = entry.value
            schema.validate_parameter(entry_as_map, entry.key, properties.elements[entry.key])
        }
    }

    /**
    * Check namespace BAM
    */
    check_bam_namespace = { Map options, String name, Map properties ->
        custom_schema_types.check_if_namespace(options[name], name)
        def given_keys = options[name].keySet() as ArrayList
        if (given_keys.size() <= 0) {
            throw new Exception("No inputs provided! Please provide inputs in the CSV or YAML.")
        }
        custom_schema_types.check_input_type_keys(given_keys, name, custom_schema_types.allowed_bam_types)

        options[name].each { entry ->
            def entry_as_map = [:]
            entry_as_map[entry.key] = entry.value
            schema.validate_parameter(entry_as_map, entry.key, properties.elements[entry.key])
        }
    }

    /**
    *   Check namespace for resource updates
    */
    check_resource_update_namespace = { Map options, String name, Map properties ->
        custom_schema_types.check_if_namespace(options[name], name)
        def given_keys = options[name].keySet() as ArrayList
        if (given_keys.size() <= 0) {
            return
        }
        custom_schema_types.check_input_type_keys(given_keys, name, custom_schema_types.allowed_resource_types)

        options[name].each { entry ->
            def entry_as_map = [:]
            entry_as_map[entry.key] = entry.value
            schema.validate_parameter(entry_as_map, entry.key, properties.elements[entry.key])
        }
    }

    /**
    * Check if proper BAM entry list
    */
    check_bam_list = { Map options, String name, Map properties ->
        custom_schema_types.check_if_list(options[name], name)
        for (item in options[name]) {
            schema.check_path(item, 'r')
        }
    }

    /**
    *   Check list of resource updates
    */
    check_resource_update_list = { Map options, String name, Map properties ->
        custom_schema_types.check_if_list(options[name], name)
        for (item in options[name]) {
            custom_schema_types.check_if_process_list(item[0], name)
            custom_schema_types.check_if_number(item[1], name)
        }
    }

    types = [
        'InputNamespace': custom_schema_types.check_input_namespace,
        'InputBAMNamespace': custom_schema_types.check_bam_namespace,
        'BAMEntryList': custom_schema_types.check_bam_list,
        'ResourceUpdateNamespace': custom_schema_types.check_resource_update_namespace,
        'ResourceUpdateList': custom_schema_types.check_resource_update_list
    ]
}