🏴󠁧󠁢󠁷󠁬󠁳󠁿 ⏏️ ☠️ Erstellen Sie Ihre Funktionen in SIL ⤵️ 👩🏻‍🌾 🧑🏽

Hallo alle zusammen!

In diesem Artikel möchte ich erklären, wie ich meine Funktion in SIL erstellen kann.

Einführung

SIL steht für Simple Issue Language und wurde von cPrime-Entwicklern entwickelt, um manuelle Aktionen in Atlassian Jira und Confluence zu automatisieren.

Der Hauptvorteil von SIL besteht darin, dass SIL Funktionen enthält, für deren Verwendung keine Kenntnisse der Atlassian Jira- oder Atlassian Confluence-APIs erforderlich sind. Dies reduziert den Schwellenwert für die Eingabe von SIL erheblich und macht das Volumen von SIL-Programmcode kleiner als bei ähnlichem Java- oder Groovy-Code.

Beispielsweise möchten Sie auf Anfrage Tickets von Jira auswählen, damit Sie einige Aktionen ausführen können. Dazu müssten Sie in Java oder Groovy ein Dutzend Codezeilen schreiben. Auf SIL ist dies eine Zeile:

selectIssues(" JQL ");

Darüber hinaus müssten Sie in Java oder Groovy die Kompatibilität des Codes auf Jira 7 und Jira 8 sicherstellen. In SIL müssen Sie nicht über Kompatibilität nachdenken. SelectIssues funktioniert auf allen von SIL unterstützten Versionen von Jira.

Mehr über SIL erfahren Sie hier .
Aber was ist, wenn ich so etwas tun muss, warum gibt es in SIL keine Funktionen? Zum Beispiel muss ich Daten aus dem Table Grid Next Generation-Plugin abrufen oder eine PDF-Datei mit dem PDF-Exporter für das Jira-Plugin generieren.

In diesem Fall haben Sie zwei Möglichkeiten:

SIL Groovy Connector - Mit diesem Plugin können Sie Code mithilfe der Jira Java API in Java oder Groovy schreiben und diesen Code aus einem SIL-Skript aufrufen.
Schreiben Sie Ihr Jira-Plugin, das Ihre Funktionen zu SIL hinzufügt, und verwenden Sie Ihre Funktionen dann in SIL-Skripten

In diesem Artikel konzentrieren wir uns darauf, wie Sie Ihr Jira-Plugin schreiben, um die Funktionen von SIL zu erweitern. Um die Schritte in diesem Artikel zu wiederholen, benötigen Sie das Atlassian SDK und git.

Stellen Sie den Maven-Archetyp ein

Ein Plugin, das SIL erweitert, muss eine Logik enthalten, die Ihre Funktionen zu SIL hinzufügt. Um diese Logik nicht jedes Mal zum Plugin hinzuzufügen, sondern sich nur auf das Schreiben von Funktionen zu konzentrieren, habe ich den Maven-Archetyp erstellt, der alles erstellt, was Sie im neuen Plugin benötigen.

Klonen Sie zunächst den Archetyp aus dem Repository:

git clone https://alex1mmm@bitbucket.org/alex1mmm/sil-extension-archetype.git --branch v1 --single-branch

Der Ordner sil-extenstion-archetype wird erstellt. Lassen Sie uns darauf eingehen:

cd sil-extension-archetype

Installieren Sie nun den Archetyp in Ihrem lokalen Maven-Repository:

atlas-mvn install

Erstellen Sie ein Plugin

Gehen Sie zum Ordner oben und erstellen Sie ein neues Plugin

cd ..
atlas-mvn archetype:generate -DarchetypeCatalog=local

Beim Erstellen eines Projekts über maven werden Ihnen Standardfragen gestellt. Ich gebe meine Antworten auf die Fragen. Sie können sie ändern.

Choose archetype:

1: local -> com.cprime.jira.sil.extension:sil-extension-archetype (This is the com.cprime.jira.sil.extension:sil-extension plugin for Atlassian JIRA.)
Choose a number or apply filter (format: [groupId:]artifactId, case sensitive contains): : 

Define value for property 'groupId': ru.matveev.alexey.sil.extension
Define value for property 'artifactId': sil-extension
Define value for property 'version' 1.0-SNAPSHOT: : 
Define value for property 'package' ru.matveev.alexey.sil.extension: : 

Confirm properties configuration:
groupId: ru.matveev.alexey.sil.extension
artifactId: sil-extension
version: 1.0-SNAPSHOT
package: ru.matveev.alexey.sil.extension

 Y: : Y

Danach wird das Plugin erstellt.

Plugin testen

Gehen Sie zum erstellten Ordner (in meinem Fall handelt es sich um die Sil-Erweiterung) und führen Sie Jira aus:

cd sil-extension
atlas-run</code>
 Jira   
<code>http://localhost:2990/jira/plugins/servlet/silmanager?autoSelectTree=sil.scripts

Sie sehen den SIL Manager-Bildschirm. Wählen Sie die Option Neue Datei:

Erstellen Sie eine test.sil-Datei mit den folgenden Inhalten:

runnerLog(SayHello("Alexey"));
string[] res = SayHello2("Alexey", "Matveev");
runnerLog(res[0]);
runnerLog(res[1]);
res = SayHello3("Alexey", "Matveev");
runnerLog(res["param1"]);
runnerLog(res["param2"]);

Der Bildschirm in Jira sieht

ungefähr so aus: Unser Plugin hat drei Funktionen hinzugefügt: SayHello, SayHello2, SayHello3. Test.sil überprüft, ob Funktionen zu SIL hinzugefügt wurden.

Führen Sie test.sil aus, indem Sie auf die Schaltfläche Ausführen klicken. Auf der Registerkarte Konsole sollte der folgende Text angezeigt werden:

Hello Alexey
Hello Alexey
Hello Matveev
Hello Alexey
Hello Matveev
Done.

Wenn Sie einen solchen Text gesehen haben, wurden unsere Funktionen erfolgreich zu SIL hinzugefügt.

Lassen Sie uns nun darüber sprechen, was im Plugin geändert werden muss, um unsere eigene Funktion zu erstellen.

Erstellen Sie eine Java-Klasse für unsere Funktion

Jede Funktion, die Sie zu SIL hinzufügen möchten, muss eine eigene Klasse haben. Diese Klasse muss ein Nachkomme der AbstractSILRoutine-Klasse sein.

Schauen wir uns die verfügbaren Beispiele an, um zu verstehen, was zu einer neuen Klasse hinzugefügt werden muss.

SayHello.java

public class SayHello extends AbstractSILRoutine<MutableString> { 
  private static final SILType[][] types = {{ TypeInst.STRING }};

  public SayHello(ClassLoader classLoader, String name) { 
    super(classLoader, name, types);
  }

  @Override 
  public SILType<MutableString> getReturnType() { return TypeInst.STRING; }

  @Override 
  protected SILValue<MutableString> runRoutine(SILContext silContext,                                   List<SILValue<?>> list) { 
    SILValue param = list.get(0); 
    return SILValueFactory.string( "Hello " + param.toStringValue());
 }
  @Override 
  public String getParams() { return "(name)"; }

Erste Linie:

private static final SILType[][] types = {{ TypeInst.STRING }};

Diese Zeile definiert die Typen und die Anzahl der Parameter, die an Ihre Funktion übergeben werden. Die Funktion in SIL sieht folgendermaßen aus:

mymethod(myparameter);

Dementsprechend bedeutet {{TypeInst.STRING}}, dass wir einen Parameter haben und sein Typ String ist. Wenn Sie zwei Parameter vom Typ String übergeben möchten, müssen Sie den String wie folgt ändern:

private static final SILType[][] types = {{ TypeInst.STRING, TypeInst.STRING }};

In SIL können Sie Ihre Funktion folgendermaßen aufrufen:

mymethod(myparameter1, myparameter2);

Wenn Ihre Funktion einen oder zwei Parameter akzeptieren kann. Dieser Begriff wird folgendermaßen aussehen:

private static final SILType[][] types = {{ TypeInst.STRING},  
                                                          {TypeInst.STRING, TypeInst.STRING }};

Als nächstes kommt:

public class SayHello extends AbstractSILRoutine<MutableString>

Wir erben unsere Klasse von AbstractSILRoutine, was bedeutet, dass unsere Klasse einen Parameter vom Typ String zurückgibt.

Des Weiteren:

public SayHello(ClassLoader classLoader, String name) { 
  super(classLoader, name, types);
}

Dies ist der Konstruktor. Sie müssen wahrscheinlich nichts daran ändern.

Des Weiteren:

@Override 
public SILType<MutableString> getReturnType() { return TypeInst.STRING; }

Hier bestimmen wir den Typ des zurückgegebenen Parameters. In unserem Fall ist es String.

Des Weiteren:

@Override 
protected SILValue<MutableString> runRoutine(SILContext silContext, List<SILValue<?>> list) { 
SILValue param = list.get(0); 
return SILValueFactory.string( "Hello " + param.toStringValue());
}

Dies ist der Haupteinstiegspunkt für Ihre Funktion. Wenn Sie eine Funktion in SIL ausführen, gelangen Sie hierher. Alle Logik ist hier.

Diese Funktion

akzeptiert zwei Parameter: silContext - Ermöglicht das Abrufen der Variablen Jira und SIL.

Beispielsweise funktioniert Ihr SIL-Skript als Post-Funktion und Sie möchten ein Ticket erhalten, unter dem das Skript ausgeführt wird:

Issue issue = (Issue) silContext.getAllMetaInformation().get("issue");

list - Ermöglicht das Abrufen der Werte von Parametern, die an die SIL-Funktion übergeben wurden.

SILValue param = list.get(0);

Linie:

SILValueFactory.string( "Hello " + param.toStringValue());

gibt den Wert zurück. Sie müssen Werte zurückgeben, die SIL versteht. Verwenden Sie daher SILValueFactory, um Werte zu generieren.

Des Weiteren:

@Override 
public String getParams() { return "(name)"; }

Dies definiert den Funktionstyp in SIL Manager. Wenn Sie mit der Eingabe im SIL-Manager beginnen, wird Ihnen ein Hinweis auf die verfügbaren Funktionen angezeigt. In unserem Fall sehen Sie:

yourmethod(name)

Fügen Sie unsere Klasse der SIL-Engine hinzu

Sie haben Ihre Klasse erstellt. Jetzt müssen Sie SIL auf Ihre Funktion aufmerksam machen. Dies erfolgt in der Datei ESLauncher.java. Diese Datei enthält folgende Zeilen:

RoutineRegistry.register(new SayHello( classLoader,"SayHello"));

Diese Zeile besagt, dass wir die SayHello-Klasse unter dem Namen SayHello zu SIL hinzufügen. Der Klassenname und die Funktion stimmen möglicherweise nicht überein.

Fügen Sie als Nächstes die folgende Zeile hinzu:

RoutineRegistry.unregister("SayHello");

Ändern Sie SayHello in den Namen Ihrer Funktion. Diese Zeile entlädt Ihre Funktion von SIL, wenn Sie Ihr Plugin von Jira entfernen.

Mehr über SIL

In der SayHello2-Klasse geben wir eine Liste zurück.

SILValue param1 = list.get(0); 
SILValue param2 = list.get(1); 
List<String> res = new ArrayList<>(); 
res.add("Hello " + param1.toStringValue()); 
res.add("Hello " + param2.toStringValue()); 
return SILValueFactory.stringArray(res);

Damit dies funktioniert, müssen Sie auch den Rückgabewert in TypeInst.STRING_ARR ändern und mit KeyableArraySILObject von AbstractSILRoutine erben.

In SIL rufen Sie SayHello2 folgendermaßen auf:

string[] res = SayHello2("Alexey", "Matveev");
runnerLog(res[0]);
runnerLog(res[1]);

In SayHello3 geben wir Map zurück:

SILValue param1 = list.get(0); 
SILValue param2 = list.get(1); 
Map<String, String> res = new HashMap<>(); 
res.put("param1","Hello " + param1.toStringValue()); 
res.put("param2","Hello " + param2.toStringValue()); 
return SILValueFactory.stringArray(res);

In SIL können Sie SayHello3 folgendermaßen aufrufen:

res = SayHello3("Alexey", "Matveev");
runnerLog(res["param1"]);
runnerLog(res["param2"]);

In diesem Fall erhalten wir die Elemente des Arrays nicht nach Index, sondern nach Schlüsseln.

Wenn Sie sich den Code in Java ansehen, arbeiten wir in beiden Fällen mit KeyableArraySILObject. Tatsache ist, dass in SIL List und Map von der KeyableArraySILObject-Klasse implementiert werden. Jene. Auf jedes Array in SIL kann entweder per Index oder per Schlüssel zugegriffen werden.

Wir übergeben ein Array als Parameter

Wir können ein Array von der SIL-Funktion zurückgeben. Nun wollen wir sehen, wie ein Array als Parameter übergeben wird.

Der Code sieht folgendermaßen aus:

@Override
protected SILValue<MutableString> runRoutine(SILContext silContext, List<SILValue<?>> list) {
    GenericArraySILObject rowsToUpdate =  (GenericArraySILObject) list.get(0).getObject();
    Map<String, int[]> keys = rowsToUpdate.getKeysMapping()
......
}

Zuerst erhalten wir das Objekt der GenericArraySILObject-Klasse aus dem Parameter und dann die Map daraus.

In SIL können Sie ein Array wie folgt übergeben:

string[] arr;
arr["key1"] = "value1";
arr["key2"] = "value2";
yourmethod(arr);

Damit ist dieser Artikel abgeschlossen. Ich hoffe, Sie haben genug Wissen gesammelt, um Ihre Funktion in SIL zu schreiben.

Erstellen Sie Ihre Funktionen in SIL