/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
////////////////////////////////////////////////////////////////////////
//
// Groovy script to generate a types.xml file from a text file in
// a simplified syntax
// This script expects two files names TypeDefinitions.txt and
// PropertyDefinitions.txt in the same directory and generates
// file types.xml that can be imported into the InMemoryServer
//
////////////////////////////////////////////////////////////////////////
def genCommons1(name, id, descr) {
def id1 = id
def localName = name
def ns = ""
// allow syntax name;localName;namespace in property name line
if (id.contains(";")) {
names = id.tokenize(";")
if (names.size() > 0)
id1 = names[0];
if (names.size() > 1)
localName = names[1];
if (names.size() > 2)
ns = names[2];
}
outFile.println(" " + id1 + "")
outFile.println(" " + localName + "")
outFile.println(" " + name + "")
outFile.println(" " + name.replaceAll(" ", "_").toUpperCase() + "")
outFile.println(" " + descr + "")
outFile.println(" " + ns + "")
}
//////////////////////////////////////////////////////////////////
def genCommons2(choices, cardinality, updatability, required, queryable, orderable) {
def cardinalityStr
def updatabilityStr
def requiredStr
def queryableStr
def orderableStr
if (updatability.toLowerCase().startsWith("readonly"))
updatabilityStr = "readonly"
else if (updatability.toLowerCase().startsWith("oncreate"))
updatabilityStr = "oncreate"
else if (updatability.toLowerCase().startsWith("whencheckedout"))
updatabilityStr = "whencheckedout"
else
updatabilityStr = "readwrite"
if (required.toLowerCase().startsWith("true"))
requiredStr = "true"
else
requiredStr = "false"
if (cardinality.toLowerCase().startsWith("multi"))
cardinalityStr = "multi"
else
cardinalityStr = "single"
if (queryable.toLowerCase().startsWith("true"))
queryableStr = "true"
else
queryableStr = "false"
if (orderable.toLowerCase().startsWith("true"))
orderableStr = "true"
else
orderableStr = "false"
outFile.println(" " + cardinalityStr + "")
outFile.println(" " + updatabilityStr + "")
outFile.println(" false")
outFile.println(" " + requiredStr + "")
outFile.println(" " + queryableStr + "")
outFile.println(" " + orderableStr + "")
outFile.println(" false")
if (null != choices)
genChoices(choices)
}
//////////////////////////////////////////////////////////////////
def genBoolean (name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable) {
outFile.println(" ")
genCommons1(name, uuid, descr)
outFile.println(" boolean")
genCommons2(choices, cardinality, updatability, required, queryable, orderable)
outFile.println(" ")
}
//////////////////////////////////////////////////////////////////
def genDate (name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable) {
outFile.println(" ")
genCommons1(name, uuid, descr)
outFile.println(" datetime")
genCommons2(choices, cardinality, updatability, required, queryable, orderable)
outFile.println(" ")
}
//////////////////////////////////////////////////////////////////
def genId (name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable) {
outFile.println(" ")
genCommons1(name, uuid, descr)
outFile.println(" id")
genCommons2(choices, cardinality, updatability, required, queryable, orderable)
outFile.println(" ")
}
45//////////////////////////////////////////////////////////////////
def genInteger (name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable) {
outFile.println(" ")
genCommons1(name, uuid, descr)
outFile.println(" integer")
genCommons2(choices, cardinality, updatability, required, queryable, orderable)
outFile.println(" ")
}
//////////////////////////////////////////////////////////////////
def genString (name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable) {
outFile.println(" ")
genCommons1(name, uuid, descr)
outFile.println(" string")
genCommons2(choices, cardinality, updatability, required, queryable, orderable)
outFile.println(" ")
}
//////////////////////////////////////////////////////////////////
def genDecimal (name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable) {
outFile.println(" ")
genCommons1(name, uuid, descr)
outFile.println(" decimal")
genCommons2(choices, cardinality, updatability, required, queryable, orderable)
outFile.println(" ")
}
//////////////////////////////////////////////////////////////////
def genChoices (choices) {
choices.each {
keyValue = it.tokenize("=")
String key = keyValue.get(0).trim()
String value = keyValue.get(1).trim()
// println("Found enum with key: " + key + " value: " + value)
outFile.println(" ")
outFile.println(" " + key + "")
outFile.println(" ")
}
}
//////////////////////////////////////////////////////////////////
def genTypeDef (name, id, descr, typeKind, parentType, props) {
String xsiType
String baseId
switch (typeKind) {
case "document":
xsiType = "cmisTypeDocumentDefinitionType"
baseId = "cmis:document"
break;
case "folder":
xsiType = "cmisTypeFolderDefinitionType"
baseId = "cmis:folder"
break;
default:
println("Error illegal type: " + typeKind)
}
if (parentType == null)
parentType = baseId
def id1 = id
def localName = name
def ns = ""
// allow syntax name;localName;namespace in property name line
if (id.contains(";")) {
names = id.tokenize(";")
if (names.size() > 0)
id1 = names[0];
if (names.size() > 1)
localName = names[1];
ns = names[2];
}
outFile.println("")
outFile.println(" " + id1 + "")
outFile.println(" " + localName + "")
outFile.println(" " + ns + "")
outFile.println(" " + parentType + "")
outFile.println(" " + name + "")
outFile.println(" " + name.replaceAll(" ", "_").toUpperCase() + "")
outFile.println(" " + descr + "")
outFile.println(" " + baseId + "")
outFile.println(" true")
outFile.println(" true")
outFile.println(" true")
outFile.println(" true")
outFile.println(" true")
outFile.println(" false")
outFile.println(" true")
if (typeKind == "document") {
outFile.println(" false")
outFile.println(" allowed")
}
if (props != null)
props.each {
def propDef = propDefsMap.get(it)
if (propDef != null)
genPropertyDef (propDef.type, propDef.name, propDef.id, propDef.descr, propDef.choices,
propDef.cardinality, propDef.updatability, propDef.required, propDef.queryable, propDef.orderable)
else
println ("Error: unknown property definition " + it + " in type definition " + name)
}
outFile.println("")
outFile.println()
outFile.flush()
}
//////////////////////////////////////////////////////////////////
def genPropertyDef(type, name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable) {
switch (type) {
case "boolean":
genBoolean(name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable)
break
case "datetime":
genDate(name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable)
break
case "id":
genId(name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable)
break
case "integer":
genInteger(name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable)
break
case "string":
genString(name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable)
break
case "decimal":
genDecimal(name, uuid, descr, choices, cardinality, updatability, required, queryable, orderable)
break
default:
println("!!!Error: unknown property type " + type);
}
}
//////////////////////////////////////////////////////////////////
def readPropertiesFile(inputFile) {
def propDefMap = [:]
def inFile = new File(inputFile).newReader()
while (inFile.readLine() != null) {
def typeLine = inFile.readLine()
def name = inFile.readLine().trim()
println(" processing property: " + name + " type: " + typeLine)
def id = inFile.readLine().trim()
def descr = inFile.readLine().trim()
def attrs = inFile.readLine().trim()
def choices = null;
def cardinality, updatability, required, queryable, orderable
type = typeLine.tokenize().get(0)
def arr = attrs.split(",")
cardinality = arr.length > 0 ? arr[0].trim() : null
updatability = arr.length > 1 ? arr[1].trim() : null
required = arr.length > 2 ? arr[2].trim() : null
queryable = arr.length > 2 ? arr[3].trim() : "false"
orderable = arr.length > 2 ? arr[4].trim() : "false"
if (typeLine.contains("enum:")) {
choices = typeLine[typeLine.indexOf("enum:")+ 5..typeLine.length()-1].tokenize(";")
}
propDefMap.put(name, [name:name, id:id, descr:descr, type:type, choices:choices, cardinality:cardinality,
updatability:updatability, required:required, queryable:queryable, orderable:orderable])
}
return propDefMap;
}
//////////////////////////////////////////////////////////////////
def readTypeDefinitions(inputFile) {
def typeDefMap = [:]
def inReader = new File(inputFile).newReader()
// def inReader = new StringReader(typeDefInput)
def line = inReader.readLine()
while (line != null) {
def kind = inReader.readLine().trim()
def idLine = inReader.readLine().trim()
def name = inReader.readLine().trim()
def descr = inReader.readLine().trim()
def arr = idLine.split(":")
def id = arr.length>0 ? arr[0].trim() : null
def superType = arr.length>1 ? arr[1].trim() : null
def propDefs = []
def readProperties = true;
while (readProperties) {
line = inReader.readLine()
if (line != null && line.size() > 0)
propDefs.push(line.trim())
else
readProperties = false;
}
println("Reading type def " + name)
typeDefMap.put(name, [name: name, id: id, kind: kind, super: superType, descr: descr, props: propDefs])
}
return typeDefMap
}
//////////////////////////////////////////////////////////////////
def writeTypes(typeDefsMap) {
outFile.println("")
for ( e in typeDefsMap ) {
println("generating type" + e.value.name)
genTypeDef (e.value.name, e.value.id, e.value.descr, e.value.kind, e.value.super, e.value.props)
}
outFile.println("")
}
//////////////////////////////////////////////////////////////////
def writePropDefs(propDefsMap) {
for ( e in propDefsMap ) {
println("generating property" + e.value.name)
genPropertyDef (e.value.type, e.value.name, e.value.id, e.value.descr, e.value.choices,
e.value.cardinality, e.value.updatability, e.value.required)
}
}
//////////////////////////////////////////////////////////////////
// Main program
println("Starting...")
def propsFile = "PropertyDefinitions.txt";
def typesFile = "TypeDefinitions.txt";
def outFileName = "types.xml";
outFile = new File(outFileName).newPrintWriter()
println("Reading type definitions from file " + typesFile);
typeDefsMap = readTypeDefinitions(typesFile)
println("Reading property definitions from file " + propsFile);
propDefsMap = readPropertiesFile(propsFile)
println("Writing out to " + outFileName);
outFile.println("")
writeTypes(typeDefsMap)
outFile.close()
println("...Done.")