{"id":9558,"date":"2023-01-24T19:00:00","date_gmt":"2023-01-24T17:00:00","guid":{"rendered":"https:\/\/u-labs.de\/portal\/?p=9558"},"modified":"2023-01-24T13:33:24","modified_gmt":"2023-01-24T11:33:24","slug":"websphere-java-anwendung-reverse-engineering-analysieren-java-code-hinter-der-connections-atom-api-fuer-communitys","status":"publish","type":"post","link":"https:\/\/u-labs.de\/portal\/websphere-java-anwendung-reverse-engineering-analysieren-java-code-hinter-der-connections-atom-api-fuer-communitys\/","title":{"rendered":"(WebSphere) Java-Anwendung per Reverse Engineering analysieren: Java-Code hinter der Connections Atom-API f\u00fcr Communitys"},"content":{"rendered":"

Dieser Beitrag zeigt, wie man den Code einer auf WebSphere laufenden propriet\u00e4ren Java-Anwendung analysieren kann. Der Anwendungsfall ist hierf\u00fcr die Communitys-Anwendung von HCL Connections, mit dem Ziel, mehr \u00fcber die Funktionsweise der Atom-API zu erfahren.<\/p>\n

Ausgangslage: Eine fehlerhafte Dokumentation<\/h2>\n

Mein Vorhaben war recht simpel: Eine Community automatisiert per API anlegen, damit dies in Drittanbieter-Software eingebunden werden konnte. In der Dokumentation findet sich dazu ein Artikel inklusive Beispiel des Atom-Dokumentes<\/a>. Beschrieben sind die Felder author<\/strong> und contributor<\/strong> dort nicht, allerdings enth\u00e4lt dieser Artikel mehr Informationen \u00fcber contributor<\/strong><\/a>. Jedoch wird per API lediglich die Community mit dem Nutzer als Eigent\u00fcmer angelegt, der sich f\u00fcr die API-Anfrage authentifiziert. Eine ganze Reihe an abge\u00e4nderten Tests \u00e4ndert daran nichts und f\u00fchrt auch zu keinen Fehlern, die m\u00f6glicherweise weitere Hinweise liefern. Es scheint, als w\u00fcrden diese beiden Felder an dieser Stelle schlichtweg ignoriert.<\/p>\n

\"\"<\/p>\n

Da es sich um propriet\u00e4re Software handelt, kann man leider nicht mal eben einen Blick in den Quellcode werfen und ggf. sogar mit Debugging weitere Informationen ermitteln. Bei Java mit seinem Bytecode haben wir jedoch den gro\u00dfen Vorteil, dass sich dieser recht leicht dekompilieren l\u00e4sst. Dies hat zwar auch seine Nachteile. So k\u00f6nnen wir den Code nicht einfach ver\u00e4ndern und es gehen Informationen wie etwa die Bezeichnungen von Variablen verloren. Doch es bleibt die einzige M\u00f6glichkeit, mehr \u00fcber die Funktion zu erfahren. Immerhin erh\u00e4lt man dadurch wieder Java-Code und muss nicht mit Assembler hantieren, was bei einem Projekt dieser Gr\u00f6\u00dfe zu einer sinnvollen praktikablen Fehleranalyse v\u00f6llig unrealistisch sein d\u00fcrfte.<\/p>\n

M\u00f6glicherweise muss der Code aber auch nicht ver\u00e4ndert werden – sondern es gen\u00fcgt bereits ein Java-Namensraum, \u00fcber den sich das Trace-Logging in WebSphere aktivieren l\u00e4sst. Bei den bisherigen Versuchen meldet sich eine Klasse namens MemberProfile<\/strong> im SystemOut.log<\/strong> des InfraClusters<\/strong> zu Wort, jedoch ohne Namensraum. Diesen k\u00f6nnen wir anhand des Java-Codes ermitteln.<\/p>\n

Export der EAR-Datei<\/h2>\n

Zun\u00e4chst m\u00fcssen wir die Ear-Datei herunterladen. Ein sogenanntes Enterprise Archive<\/strong> ist im Grunde ein ZIP-Archiv mit den kompilierten Class-Dateien sowie weiteren Metadaten zur Java-Anwendung. Auch JSPs sind dabei. Da diese nicht kompiliert werden, kann man sie ohne Decompiler analysieren und mit jedem Texteditor ver\u00e4ndern. Interessant ist hier vor allem die Ear-Datei der Communitys-Anwendung – dar\u00fcber laufen auch die Atom-APIs. Man kann sie in der WebSphere ISC unter Applications > Application Types > WebSphere enterprise applications<\/strong> anhaken und per Export<\/strong> herunterladen:<\/p>\n

\"\"<\/a><\/figure>\n

Analyse mit dem Java Decompiler JD-GUI<\/em><\/h2>\n

Die Ear-Datei k\u00f6nnte man mit jedem beliebigen Archivprogramm entpacken. Das ist jedoch wenig zielf\u00fchrend: Sie enth\u00e4lt Gro\u00dfteils weitere War- und Jar-Dateien der einzelnen Komponenten. Auch das sind gepackte Java-Anwendungen. Ein Teil der Inhalte sind direkt lesbar, etwa die JSPs. Das Layout ist jedoch wenig hilfreich, wir ben\u00f6tigen den Bytecode in den Class-Dateien.<\/p>\n

\"\"<\/a><\/figure>\n

Statt das Archiv zu entpacken, wird ein Programm zum dekopilieren ben\u00f6tigt. Es macht den Bytecode wieder lesbar. Ein solches quelloffenes Tool ist der Java Decompiler<\/a>. Man kann ihn in die Entwicklungsumgebung Eclipse integrieren, oder in Form von JD-GUI als eigenst\u00e4ndige Anwendung nutzen – wir werden von letzterem Gebrauch machen. Die Software hat eine lange Geschichte. Bereits zu U-Hacks Zeiten kam sie zur Analyse des Knuddels-Applets zum Einsatz. Ihr k\u00f6nnt entweder die fertigen Pakete\/Binaries herunterladen, oder die portable Jar-Datei. Hierf\u00fcr ist lediglich Java in mindestens Version 1.8 n\u00f6tig:<\/p>\n

\n
\njava -jar ~\/Downloads\/jd-gui-1.6.6.jar\n<\/pre>\n<\/div>\n
Das zuvor heruntergeladene Communities.ear<\/strong> Archiv per Drag & Drop hinein ziehen. Im linken Bereich werden alle Inhalte sichtbar. Es ist von Vorteil, sich mit der grundlegenden Struktur von Java-Anwendungen bereits auszukennen. Ansonsten wird man etwas l\u00e4nger ben\u00f6tigen, um diese herauszufinden.<\/p>\n
\"\"<\/a><\/figure>\n
Wo ist die API?<\/h2>\n
Sp\u00e4testens wenn man bei der Anwendungslogik angelangt ist, wird der Umfang klar. Schlie\u00dflich ist darin nicht nur die API enthalten – sondern auch der Code f\u00fcr die Communitys selbst. Eine erste Orientierung bietet application.xml<\/strong> im META-INF<\/strong> Ordner. Sie enth\u00e4lt eine Zuordnung der Pfad-Pr\u00e4fixe zu den jeweiligen Modulen. Die weiter unten definierten Komponenten wie etwa die Anwendungsrollen aus der ISC sind an dieser Stelle wenig hilfreich. Interessant: Alles im Pr\u00e4fix \/communities<\/strong> wird zu comm.web.war<\/strong> geleitet. Ausgenommen sind nur zwei Unterpfade, die mit der API wenig zu tun haben. Daher schaue ich mir comm.web.war<\/strong> genauer an.<\/p>\n
\n
\"\"<\/a><\/figure>\n<\/div>\n
In WEB-INF\/jsps\/atom\/error<\/strong> sind wir der API schon recht nahe: Dort liegt die Fehlerseite, die bei fehlerhaften Anfragen den Statuscode und einen Infotext anzeigt. Durch eine Testanpassung mit einer bewussten fehlerhaften XML-Anfrage l\u00e4sst sich das best\u00e4tigen:<\/p>\n
\n
\n<error xmlns="http:\/\/www.ibm.com\/xmlns\/prod\/sn">\n\t<danielWasHere>true<\/danielWasHere>\n\t<code>400<\/code>\n\t<message>\n\t\t\t\tInvalid member entry.\n\t<\/message>\n \t<trace>\n\t<\/trace>\n<\/error>\n<\/pre>\n<\/div>\n
Wir sind also auf dem richtigen Weg. Ansonsten befindet sich im directory<\/strong> Ordner von jsps<\/strong> eine Reihe an Templates, welche die XML-Antworten generieren: community.jsp<\/strong> beispielsweise f\u00fcr eine einzige Community. Darin sind auch Filter enthalten. So wird beispielsweise die E-Mail Adresse f\u00fcr Externe ausgeblendet, damit diese sich per API keine Liste aller Mitarbeiter bzw. sogar externer (Konkurrenz-) Partner generieren k\u00f6nnen. Das html<\/strong> Verzeichnis enth\u00e4lt ebenfalls JSPs, allerdings f\u00fcr das Web. Etwa die Startseite mit den verschiedenen Layouts. Interessant, aber all diese Ansichten helfen uns nicht weiter – wir brauchen die Anwendungslogik.<\/p>\n
In dieser Hinsicht befindet sich nichts relevantes in diesem Modul. Daher habe ich den Unterordner lib<\/strong> angeschaut – vermutlich wurde Layout und Logik getrennt, was \u00fcblich und sinnvoll ist. Mehrere mit comm.*<\/strong> startende Jar-Dateien fallen auf, da comm<\/strong> offensichtlich als Abk\u00fcrzung f\u00fcr Communitys verwendet wurde. Nur com<\/strong> w\u00e4re logischer, steht allerdings ohne Pr\u00e4fix in Konflikt mit dem com<\/strong>mercial Namensraum.<\/p>\n
Jedenfalls klingt comm.api.jar<\/strong> zielf\u00fchrend. In com.ibm<\/strong> gefolgt von lconn.comm<\/strong> und data<\/strong> finden sich verschiedene Models\/DTOs, etwa CommunityValues<\/strong> – allerdings ohne Logik. Sonst gibt es nur tango<\/strong>, der wenig vielversprechend klingt, aber andererseits auch die Frage aufwirft, was da wohl drin liegt. Einiges wie sich zeigt, config<\/strong> enth\u00e4lt mit dem ConfigManager<\/strong> jene Klasse, um die Anwendungsspezifische XML-Datei im LotusConnections-config<\/strong> Ordner zu parsen. Thematisch passender wirkt Community<\/strong> in data<\/strong>, dies scheint das Model einer Community zu sein. Richtig interessant wird es im Ordner service<\/strong>: In der unscheinbaren Klasse TangoService<\/strong> liegt eine Schnittstelle, die Methoden wie createCommunity<\/strong> oder updateCommunity enth\u00e4lt:<\/strong><\/p>\n
\"\"<\/a><\/figure>\n
\u00dcbrigens ist AntiVirusFilter<\/strong> in util<\/strong> f\u00fcr das senden von Dateien an einen Virenscanner zust\u00e4ndig. Eine Klasse die man nicht unbedingt hier erwartet, da die Konfiguration daf\u00fcr in der LCC liegt und nicht in Communitys.<\/p>\n
Was die API angeht, sehe ich keine Implementierung und schaue daher weiter in comm.web.jar<\/strong>, in dem sich mit tango.web<\/strong> ein bekannter Namensraum findet. Hier gibt es ein Unterpaket atom<\/strong> mit einer Klasse AtomParser<\/strong>. Parst dieser eine Community als Atom-Feed oder anders herum? Es handelt sich um letzteres, also genau die Richtung, welche wir bei einer schreibenden Anfrage ben\u00f6tigen:<\/p>\n
\"\"<\/a><\/figure>\n
Die Methode convertEntry2Community<\/strong> wird hierbei aufgerufen. Sie erh\u00e4lt ein Entry<\/strong> Objekt – eine Schnittstelle, die Getter- und Setter einer per API erhaltene Community beschreibt. Dies liegt allerdings in einem ganz anderen Namensraum, der org.apache.abdera.model<\/strong> hei\u00dft. Dass wir dort richtig sind, l\u00e4sst sich \u00fcbrigens ebenfalls verifizieren: Zu Beginn wird gepr\u00fcft, ob der Community-Eintrag (<entry><\/strong>) g\u00fcltig ist. Falls nicht, wird eine Exception mit dem Bezeichner atom.parser.invalidCommunityEntryType<\/strong> geworfen. Den Text k\u00f6nnt ihr in den Properties nachlesen. Um ihn zu provozieren, gen\u00fcgt es, statt <entry><\/strong> beispielsweise <entry1><\/strong> zu senden. Dann erhalten wir besagten Text Invalid Community Entry<\/em>. Die Exception wird in AtomExceptionHandler<\/strong> abgefangen, f\u00fcr andere Fehler setzt dieser Handler den Schl\u00fcssel aus den Properties sowie den Statuscode.<\/p>\n
\"\"<\/a><\/figure>\n
Was haben wir gelernt?<\/h3>\n
Schaut man sich die komplette Methode genauer an, lassen sich zwei Erkenntnisse daraus gewinnen:<\/p>\n
    \n
  1. Es k\u00f6nnen ein paar weitere Eigenschaften gesetzt werden, die im Wiki-Artikel der Doku nicht vermerkt sind. Zum Beispiel, ob die Mitglieder E-Mails versenden d\u00fcrfen. <\/li>\n
  2. Besitzt Entry<\/strong> zwei Methoden f\u00fcr die in der Doku angegebenen Eigenschaften getAuthors() <\/strong>und getContributors()<\/strong>, die jedoch nirgendwo im Code genutzt werden: <\/li>\n<\/ol>\n
    Ersteres ist positiv, da man diese Dinge beim h\u00e4ndischen Erstellen per Web ebenfalls angeben kann:<\/p>\n
    \"\"<\/a><\/figure>\n
    Im Code werden diese Werte beispielsweise wie folgt abgerufen:<\/p>\n
    \n
    \nString str10 = parseElementStrVal(paramEntry.getExtension(QN_CONNECTIONS_MEMBER_EMAIL_PRIVILEGES));\n<\/pre>\n<\/div>\n
    Die Konstanten findet ihr in der Schnittstelle AtomConstants. Dort ist neben dem Attributsname auch der korrekte Namensraum angegeben:<\/p>\n
    \n
    \npublic static final QName QN_CONNECTIONS_MEMBER_EMAIL_PRIVILEGES = new QName("http:\/\/www.ibm.com\/xmlns\/prod\/sn", "memberEmailPrivileges", "snx");\n<\/pre>\n<\/div>\n
    Wenn man sich \u00fcber die Werte unsicher ist, weil es z.B. nicht offensichtliche boolische Angaben sind wie in diesem Falle, hilft es, sich die aufgerufenen Methoden genauer anzuschauen. Oft enthalten diese Validierungscode, Mappings auf Enums oder geben anderweitig Hinweise darauf, welche Werte zul\u00e4ssig sind. Hier ist dies folgende Hilfsmethode, die aus den Zeichenketten eine passende Konstante erzeugt:<\/p>\n
    \n
    \n  public static Community.MailPrivileges toMailPrivileges(String paramString) {\n    Community.MailPrivileges mailPrivileges = null;\n    if (paramString != null)\n      if (paramString.equalsIgnoreCase("canEmailEntireCommunity")) {\n        mailPrivileges = Community.MailPrivileges.MEMBERS_FULL_PRIVILEGES;\n      } else if (paramString.equalsIgnoreCase("canEmailOwnersOnly")) {\n        mailPrivileges = Community.MailPrivileges.MEMBERS_MAIL_OWNERS_ONLY;\n      } else if (paramString.equalsIgnoreCase("emailNotAllowed")) {\n        mailPrivileges = Community.MailPrivileges.MEMBERS_CANT_MAIL;\n      }  \n    return mailPrivileges;\n  }\n<\/pre>\n<\/div>\n
    Hier sind also die Werte canEmailEntireCommunity<\/strong>, canEmailOwnersOnly<\/strong> und emailNotAllowed<\/strong> m\u00f6glich. Sie entsprechenden den drei Auswahlfeldern in den Web-Einstellungen.<\/p>\n
    Generell k\u00f6nnen wir nat\u00fcrlich die Namensr\u00e4ume nutzen, um f\u00fcr diese das Log Level auf Maximum zu erh\u00f6hen. Die Eintr\u00e4ge finden sich dann in der trace.log Datei.<\/p>\n
    \n
    \"\"<\/a><\/figure>\n<\/div>\n
    Auf den ersten Blick bietet die communityAdmin.py<\/strong> eine weitere Alternative. Jython wird in Connections eingesetzt, um Java-Methoden aus Python-Skripten heraus aufrufen zu k\u00f6nnen. Man kann eine Reihe an administrativen Operationen \u00fcber Python bzw. die wsadmin-Konsole durchf\u00fchren. In createCommunity.py <\/strong>befindet sich auch eine Methode zum Anlegen von Communitys:<\/p>\n
    \n
    \nparms=[communityName, ownerName, memberRole, eAddrs, orgId]\nsig = ["java.lang.String", "java.lang.String", "java.lang.Integer", "java.util.HashSet", "java.lang.String"]\t\t       \t\t\nrc = AdminControl.invoke_jmx(self.getMBeanName(), "createCommunityWithEmail", parms, sig)\nprint "createCommunity request processed"\n<\/pre>\n<\/div>\n
    In der Java-Anwendung gibt es daf\u00fcr verschiedene Service-Klassen. In diesem Falle ist das etwa CommunitiesAdminService<\/strong> im Namensraum com.ibm.tango.internal.service.admin.mbean<\/strong>. Diese Methode scheint dem Code nach die Mitglieder zu ber\u00fccksichtigen und sauber zur Community hinzuzuf\u00fcgen – in den Parametern lassen sich Eigent\u00fcmer und Mitglieder angeben. Leider ist diese Methode nicht direkt per Web erreichbar. <\/p>\n
    Wie legen wir nun eine Community mit Mitgliedern an?<\/h2>\n
    Leider hat all das nicht zum Erfolg gef\u00fchrt: Der hinzuzuf\u00fcgende Benutzer taucht nirgendwo auf. Auch das angeben von ung\u00fcltigen Nutzern f\u00fchrt zu keinem Fehler. Offensichtlich handelt es sich um einen Softwarefehler, der diese Felder gar nicht auswertet. Als \u00dcbergangsl\u00f6sung bleibt daher nur, die Nutzer nachtr\u00e4glich hinzuzuf\u00fcgen. Daf\u00fcr gibt es in comm.web.jar > com.ibm > tango.web > ui > actions<\/strong> weitere Klassen, die eine ganze Reihe von Funktionen abdecken. Relevant ist hier vor allem CommunityCreateAction<\/strong>. <\/p>\n
    Zun\u00e4chst jedoch zur Erstellung an sich, die \u00fcber folgenden Body m\u00f6glich ist:<\/p>\n
    \n
    \n<?xml version="1.0" encoding="UTF-8"?>\n<entry\n    xmlns="http:\/\/www.w3.org\/2005\/Atom"\n    xmlns:app="http:\/\/www.w3.org\/2007\/app"\n    xmlns:snx="http:\/\/www.ibm.com\/xmlns\/prod\/sn">\n    <title type="text">U-Labs Community<\/title>\n    <summary type="text">ignored<\/summary>\n    <content type="html">Automatisch per API erstellte Beispiel-Community<\/content>\n    <category term="community" scheme="http:\/\/www.ibm.com\/xmlns\/prod\/sn\/type"><\/category>\n    <snx:communityType>public<\/snx:communityType>\n<\/entry>\n<\/pre>\n<\/div>\n
    \n
    \n$ curl -s -D - -k -X POST -u max:cnx -H "Content-Type: application\/atom+xml" --data "@create-community.xml" https:\/\/cnx7.u-labs.de\/communities\/service\/atom\/communities\/my\nHTTP\/1.1 201 Created\n...\nLocation: https:\/\/cnx7.u-labs.de\/communities\/service\/atom\/community\/instance?communityUuid=fcedd4f4-4a05-45e5-968a-3f3f3af234a8\n...\n<\/pre>\n<\/div>\n
    Um ein Mitglied hinzuzuf\u00fcgen, wird die Id der Community ben\u00f6tigt. Die API liefert in der Regel die Adresse zum angelegten Objekt im Location<\/strong> Headerfeld, sodass ihr sie dort aus dem Parameter kopieren k\u00f6nnt. Anschlie\u00dfend f\u00fcgt ihr dies in den communityUuid<\/strong> Parameter der POST-Anfrage ein: <\/p>\n
    \n
    \n<?xml version="1.0" encoding="UTF-8"?>\n<entry xmlns="http:\/\/www.w3.org\/2005\/Atom" xmlns:app="http:\/\/www.w3.org\/2007\/app" xmlns:opensearch="http:\/\/a9.com\/-\/spec\/opensearch\/1.1\/" xmlns:snx="http:\/\/www.ibm.com\/xmlns\/prod\/sn">\n    <contributor>\n        <email>user@u-labs.de<\/email>\n        <snx:role xmlns:snx="http:\/\/www.ibm.com\/xmlns\/prod\/sn" component="http:\/\/www.ibm.com\/xmlns\/prod\/sn\/communities">member<\/snx:role>\n    <\/contributor>\n<\/entry>\n<\/pre>\n<\/div>\n
    \n
    \n$ curl -s -D - -k -X POST -u max:cnx -H "Content-Type: application\/atom+xml" --data "@add-members.xml" https:\/\/cnx7u-labs.de\/communities\/service\/atom\/community\/members?communityUuid=fcedd4f4-4a05-45e5-968a-3f3f3af234a8\nHTTP\/1.1 201 Created\n...\n<\/pre>\n<\/div>\n
    Die Community hat nun zwei Mitglieder:<\/p>\n
    \"\"<\/a><\/figure>\n
    Laut HCL-Dokumentation soll das Hinzuf\u00fcgen von Mitgliedern in der selben Anfrage m\u00f6glich sein, wie das Anlegen. In meinen Tests hat dies jedoch trotz einiger Versuche nicht funktioniert. Ein Blick auf den Code best\u00e4tigt, dass dies anscheinend nicht implementiert wurde.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Dieser Beitrag zeigt, wie man den Code einer auf WebSphere laufenden propriet\u00e4ren Java-Anwendung analysieren kann. Der Anwendungsfall ist hierf\u00fcr die Communitys-Anwendung von HCL Connections, mit dem Ziel, mehr \u00fcber die Funktionsweise der Atom-API zu erfahren. Ausgangslage: Eine fehlerhafte Dokumentation Mein Vorhaben war recht simpel: Eine Community automatisiert per API anlegen, damit dies in Drittanbieter-Software eingebunden …<\/p>\n","protected":false},"author":5,"featured_media":9572,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[765,61],"tags":[760,87,873],"class_list":["post-9558","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-hcl-connections","category-softwareentwicklung","tag-hcl-connections","tag-java","tag-websphere"],"_links":{"self":[{"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/posts\/9558","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/comments?post=9558"}],"version-history":[{"count":6,"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/posts\/9558\/revisions"}],"predecessor-version":[{"id":10051,"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/posts\/9558\/revisions\/10051"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/media\/9572"}],"wp:attachment":[{"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/media?parent=9558"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/categories?post=9558"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/u-labs.de\/portal\/wp-json\/wp\/v2\/tags?post=9558"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}