Laboratoire ICAR » Plateforme TXM

import java.nio.charset.Charset

import java.time.LocalTime

import java.time.format.DateTimeFormatter

import org.txm.utils.*

File metadataFile = new File("/home/mdecorde/TEMP/ANTRACT/AF/sujets.xlsx")

File trsDirectory = new File("/home/mdecorde/TEMP/ANTRACT/AF/trs")

def joinTRSColumn = "Lien notice principale"

def typeColumns = ["Titre propre"]

def topicColumns = ["Date de diffusion"]

def startTimeColumn = "antract_debut"

def endTimeColumn = "antract_fin"

//def metadataColumns = ["Identifiant de la notice", "Titre propre", "antract_debut", "antract_fin"]

def metadataColumns = [

                                "Titre propre", "Date de diffusion", "Identifiant de la notice", "Notes du titre", "Type de date", "Durée", "Genre", "Langue VO / VE", "Nature de production", "Producteurs (Aff.)", "Thématique",

                                "Nom fichier segmenté (info)", "antract_video", "antract_debut","antract_fin","antract_duree","antract_tc_type","antract_tc_date",

                                "Résumé", "Séquences", "Descripteurs (Aff. Lig.)", "Générique (Aff. Lig.)"]

def metadataColumnsGroups = [

        "metadata", "metadata", "metadata", "metadata", "metadata", "metadata", "metadata", "metadata", "metadata", "metadata", "metadata",

        "secondary", "secondary", "secondary","secondary","secondary","secondary","secondary",

        "text", "text", "text", "text"]

if (metadataColumns.size() != metadataColumnsGroups.size()) {

        println "ERROR in metadata declarations&groups:"

        println "COLUMNS: "+metadataColumns

        println "GROUPS : "+metadataColumnsGroups

        return

}

if (!trsDirectory.exists()) {

        println "$trsDirectory not found"

        return

}

println "Loading data from $metadataFile..."

TableReader reader = new TableReader(metadataFile)//, "\t".charAt(0), Charset.forName("UTF-8")

reader.readHeaders()

def header = reader.getHeaders()

if (!header.contains(joinTRSColumn)) {

        println "No TRS ID $joinTRSColumn column found"

        return

}

if (!header.contains(startTimeColumn)) {

        println "No start time $startTimeColumn column found"

        return

}

if (!header.contains(endTimeColumn)) {

        println "No end time $endTimeColumn column found"

        return

}

for (def col : metadataColumns) {

        if (!header.contains(endTimeColumn)) {

                println "No $col column found"

                return

        }

}

for (def col : typeColumns) {

        if (!header.contains(endTimeColumn)) {

                println "No type $col column found"

                return

        }

}

for (def col : topicColumns) {

        if (!header.contains(endTimeColumn)) {

                println "No topic $col column found"

                return

        }

}

File outputDirectory = new File(trsDirectory, "out")

println "Writing result to $outputDirectory..."

dateTimeFormatter = DateTimeFormatter.ISO_LOCAL_TIME

def strTotime(def str) {

        if (str.lastIndexOf(":") == -1) {

                return null

        }

        bonusFrame = Integer.parseInt(str.substring(str.lastIndexOf(":")+1))

        //if (str.contains("135475")) println "ERROR $str in $infos -> $bonusFrame"

        if (bonusFrame > 25) {

                bonusFrame=0;

        }

        totalFrame = str.substring(0, str.lastIndexOf(":"))

        LocalTime time1 = LocalTime.parse(totalFrame, dateTimeFormatter)

        totalFrame = (time1.getHour()*60*60) + (time1.getMinute()*60) + time1.getSecond()

                def ret = totalFrame + (bonusFrame/25)

                return ret

        }

def sectionGroupsToInsert = [:]

println "Reading data..."

while (reader.readRecord()) {

        String id = reader.get(joinTRSColumn).trim()

        if (id.endsWith(".mp4")) id = id.substring(0, id.length()-4)

        if (id.length() == 0) continue;

        if (!sectionGroupsToInsert.containsKey(id)) {

                sectionGroupsToInsert[id] = []

        }

        def section = sectionGroupsToInsert[id]

        if (reader.get(startTimeColumn) != null && reader.get(startTimeColumn).length() > 0) { // ignore non timed sections

                def m = [:]

                for (def todo : ["topic":topicColumns, "type":typeColumns]) {

                        def data = []

                        for (def col : todo.value) {

                                if (reader.get(col).trim().length() > 0) {

                                        data << reader.get(col).trim().replace("\n", "")

                                }

                        }

                        m[todo.key] = data.join("\t")

                }

                def metadataList = []

                def metadataGroupList = []

                for (int i = 0 ;  i < metadataColumns.size() ; i++) {

                        def col = metadataColumns[i]

                        String c = AsciiUtils.buildAttributeId(col)

                        m[c] = reader.get(col)

                        metadataList << c

                        metadataGroupList << metadataColumnsGroups[i]

                }

                m["metadata"] = metadataList.join("|") 

                m["metadata_groups"] = metadataGroupList.join("|")

                m["startTime"] = strTotime(reader.get(startTimeColumn))

                m["endTime"] = strTotime(reader.get(endTimeColumn))

                m["synchronized"] = "true"

                section << [m["startTime"], m["endTime"], m]

        }

}

println "Inserting sections... "+sectionGroupsToInsert.size()

ConsoleProgressBar cpb = new ConsoleProgressBar(sectionGroupsToInsert.keySet().size())

for (String id : sectionGroupsToInsert.keySet()) {

        cpb.tick()

        File trsFile = new File(trsDirectory, id+".trs")

        if (!trsFile.exists()) {

                continue

        }

        //println "Processing $id..."

        def sections = sectionGroupsToInsert[id]

        sections = sections.sort() { a, b -> a[0] <=> b[0] ?: a[1] <=> b[1] }

        // Open input file

        def slurper = new XmlParser();

        slurper.setFeature("http://apache.org/xml/features/disallow-doctype-decl", false)

        def trs = slurper.parse(trsFile.toURI().toString())

        def trsEpisodes = trs.Episode // 1

        if (trsEpisodes.size() > 1) {

                println "multiple Episode node in $trsFile"

                continue

        }

        def trsEpisode = trsEpisodes[0]

        def trsSections =  trs.Episode.Section // 1

        if (trsSections.size() > 1) {

                println "multiple Section node in $trsFile"

                continue

        }

        def trsSection = trsSections[0]

        def turns = trsSection.Turn

        def newSections = []

        def iSection = 0;

        def currentSection = null

        def currentNode = null

        for (def turn : turns) {

                def start = Float.parseFloat(turn.@startTime)

                def end = Float.parseFloat(turn.@endTime)

                def found = null;

                for (int i = iSection ; i < sections.size() ; i++) {

                        if (end < sections[i][0]) { // Turn is before section

                        } else if (sections[i][1] < start) { // Turn is before section

                        } else {

                                found = sections[i]

                                iSection = i

                                break; // stop searching and set iSection to accelerate next search

                        }

                }

                if (found == null) {

                        if (currentSection != null || currentNode == null) {

                                currentNode = new Node(trsEpisode, "Section", ["type":"Sujet non synchronisé", "topic":"none", "startTime":turn.@startTime, "endTime":"", "synchronized":"false"] )

                                currentSection = null;

                        }

                } else {

                        if (found != currentSection) {

                                if (currentNode != null && currentNode.@synchronized == "false") {

                                        def tmp = currentNode.Turn

                                        currentNode.@endTime = tmp[-1].@endTime

                                }

                                currentSection = found

                                currentNode = new Node(trsEpisode, "Section", currentSection[2])

                        }

                }

                trsSection.remove(turn)

                currentNode.append(turn)

        }

        //remove the initial section

        trsEpisode.remove(trsSection)

        outputDirectory.mkdir()

        File outfile = new File(outputDirectory, trsFile.getName())

        outfile.withWriter("UTF-8") { writer ->

                writer.write('<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE Trans SYSTEM "trans-14.dtd">\n')

                def printer = new groovy.util.XmlNodePrinter(new PrintWriter(writer))

                printer.setPreserveWhitespace(true)

                printer.print(trs)

        }

}

cpb.done()

reader.close()

println "Done."