diff --git a/project/MockDataExport.scala b/project/MockDataExport.scala
index bee338e..9649884 100644
--- a/project/MockDataExport.scala
+++ b/project/MockDataExport.scala
@@ -16,6 +16,7 @@
     lazy val orgDbOutputFile =
       settingKey[File]("Output file for the org DB JSON export")
     lazy val orgDbHeliosExportFile = settingKey[File]("HeliosData export file")
+    lazy val orgDbDataExportFile = settingKey[File]("DataExport export file")
   }
 
   import autoImport._
@@ -24,15 +25,18 @@
     orgDbOutputFile := (Compile / target).value / "mock_data" / "users.json",
     orgDbExportDir := (Compile / sourceDirectory).value / "data",
     orgDbHeliosExportFile := orgDbExportDir.value / "HeliosData.xml",
+    orgDbDataExportFile := orgDbExportDir.value / "DataExport_zam.xml",
     generateOrgDbData := {
       val file = orgDbOutputFile.value
       val heliosFile = orgDbHeliosExportFile.value
       def doExport() = {
         val heliosData =
           XML.loadFile(orgDbHeliosExportFile.value.getAbsolutePath())
+        val exportData =
+          XML.loadFile(orgDbDataExportFile.value.getAbsolutePath())
         IO.write(
           file,
-          userData(heliosData)
+          userData(heliosData, exportData)
         )
       }
       val cachedFun =
@@ -51,45 +55,104 @@
   def escaped(v: String): String = v.replaceAll("\"", "\\\"")
   def quoted(v: String): String = s""""${escaped(v)}""""
 
-  def renderValue(v: AnyRef): Option[String] = v match {
-    case o: Option[String] @unchecked => o.map(i => s"${quoted(i)}")
-    case _                            => Some(quoted(v.toString))
-  }
+  def renderValue(v: Option[String]): Option[String] =
+    v.map(i => s"${quoted(i)}")
 
-  def renderParam(n: String, v: AnyRef): Option[String] =
+  def renderParam(n: String, v: Option[String]): Option[String] =
     renderValue(v).map(r => s"""${quoted(n)}: ${r}""")
 
-  def renderParams(params: List[(String, AnyRef)]): String =
+  def renderParams(params: List[(String, Option[String])]): String =
     params.map((renderParam _).tupled).flatten.mkString(", ")
 
-  def renderUserTuple(id: String, params: List[(String, AnyRef)]): String =
-    s""""$id": {${renderParams(params)}}"""
+  def renderUserTuple(
+      id: String,
+      params: List[(String, Option[String])],
+      fce: Option[List[(String, Option[String])]],
+      pp: List[List[(String, Option[String])]]
+  ): String = {
+    val contracts = pp.map(p => s"{${renderParams(p)}").mkString(", ")
+    val mainF = fce
+      .map(renderParams)
+      .map(p => s""", "mainFunction": {$p}""")
+      .getOrElse("")
+    s""""$id": {${renderParams(
+      params
+    )} $mainF, "userContracts": [$contracts]}"""
+  }
 
-  def userData(heliosData: Elem): String = {
+  def userData(heliosData: Elem, exportData: Elem): String = {
     val zamestnanci = (heliosData \\ "ExportZamestnanecHelios")
+    val zamestnanciExport = (exportData \\ "ExportZamestnanec")
 
-    def str(a: String) = (z: scala.xml.Node) => (z \ a).text.trim
+    def str(a: String) = (z: scala.xml.Node) => Some((z \ a).text.trim)
     def optstr(a: String) = (z: scala.xml.Node) =>
       Option((z \ a).text.trim).filterNot(_.isBlank)
+    def mainFunction(a: String) = (z: scala.xml.Node) =>
+      (z \\ "ExportFunkce")
+        .find(n => (n \ "hlavniFunkce").text == "true")
+        .flatMap(str(a))
 
-    def id = str("osobniCislo")
+    def mainContract(a: String) = (z: scala.xml.Node) =>
+      (z \\ "ExportPracovniPomer")
+        .find(n => (n \ "datumUkonceni").text.isEmpty)
+        .flatMap(str(a))
 
-    val attrs = List(
-      "personalNumber" -> str("osobniCislo"),
-      "username" -> str("uzivatelskeJmeno"),
-      "givenName" -> str("jmeno"),
-      "surname" -> str("prijmeni"),
-      "titlesBeforeName" -> optstr("titulPred"),
-      "titlesAfterName" -> optstr("titulZa"),
-      "email" -> optstr("email")
-    )
+    def id = str("osobniCislo").andThen(_.get)
 
-    def renderUser(record: scala.xml.Node): String =
-      renderUserTuple(id(record), attrs.map { case (n, g) => n -> g(record) })
+    def parseRecord(attrs: List[(String, scala.xml.Node => Option[String])])(
+        record: scala.xml.Node
+    ): (String, List[(String, Option[String])]) =
+      (id(record) -> attrs.map { case (n, g) => n -> g(record) })
 
-    def renderUserList(records: Seq[scala.xml.Node]): String =
-      s"{\n\t${records.map(renderUser).mkString(",\n\t")}\n}"
+    def parseHeliosUser(
+        record: scala.xml.Node
+    ): (String, List[(String, Option[String])]) =
+      parseRecord(
+        List(
+          "personalNumber" -> str("osobniCislo"),
+          "username" -> str("uzivatelskeJmeno"),
+          "givenName" -> str("jmeno"),
+          "surname" -> str("prijmeni"),
+          "titlesBeforeName" -> optstr("titulPred"),
+          "titlesAfterName" -> optstr("titulZa"),
+          "email" -> optstr("email")
+        )
+      )(record)
 
-    renderUserList(zamestnanci)
+    def parseMainFunction(
+        record: scala.xml.Node
+    ): (String, List[(String, Option[String])]) =
+      parseRecord(
+        List(
+          "name" -> mainFunction("nazev"),
+          "dept" -> mainFunction("nazevVOJ"),
+          "ou" -> mainFunction("nazevStrediska")
+        )
+      )(record)
+
+    def parseContract(
+        record: scala.xml.Node
+    ): (String, List[(String, Option[String])]) =
+      parseRecord(
+        List(
+          "rel" -> mainContract("druh"),
+          "startDate" -> mainContract("datumNastupu"),
+          "endDate" -> mainContract("datumUkonceni")
+        )
+      )(record)
+
+    val heliosUsers = Map(zamestnanci.map(parseHeliosUser): _*)
+    val mainContracts = Map(zamestnanci.map(parseContract): _*)
+    val mainFunctions = Map(zamestnanciExport.map(parseMainFunction): _*)
+
+    val result = heliosUsers
+      .map { case (id, params) =>
+        val fce = mainFunctions.get(id)
+        val contr = mainContracts.get(id)
+        renderUserTuple(id, params, fce, contr.toList)
+      }
+      .mkString(",\n\t")
+
+    s"{\n\t${result}\n}"
   }
 }