Wie kann ich Slack-Kanäle effizient archivieren?

Slack ermöglicht die Archivierung von Kanälen. Wir haben derzeit rund 50 Kanäle, die mit 0 Benutzern nicht mehr aktiv sind.

Wie kann ich diese Kanäle effizient archivieren, ohne sie einzeln verbinden und archivieren zu müssen?

Um die Kanäle tatsächlich "zu archivieren", dh das Äquivalent zum Ausführen von "/ archive" in jedem Kanal, benötigen Sie etwas API-Magie.

Richten Sie zunächst ein API-Token für Ihren Benutzer im entsprechenden Team unter https://api.slack.com/custom-integrations/legacy-tokens ein und gehen Sie dann zu https://api.slack.com/methods/channels. Liste / Test , um eine JSON-Liste Ihrer Kanäle zusammen mit den Kanal-IDs zu erhalten.

Verwenden Sie dann diese Kanal-IDs, um https://api.slack.com/methods/channels.archive/test für die Kanäle auszuführen, die Sie archivieren möchten.

Hier ist ein schnelles und schmutziges Bash-Skript (das jq verwendet ), das ich kürzlich auf meinem Mac ausgeführt habe, um die Hunderte von Kanälen zu archivieren, die "sk-" im Kanalnamen enthielten:

TOKEN="replace-this-with-your-user-api-token-in-the-relevant-team"
curl "https://slack.com/api/channels.list?token=$TOKEN&exclude_archived=true&pretty=1" > /tmp/channels.list
IDS=$(cat /tmp/channels.list | jq '.channels[] | select(.name | contains("sk-")) | .id' | sed -e 's/"//g')
for ID in $IDS; do
    URL="https://slack.com/api/channels.archive?token=$TOKEN&channel=$ID&pretty=1"
    echo $URL
    curl "$URL"
done

Es hat die Arbeit erledigt und ungefähr 2-3 Kanäle pro Sekunde archiviert.

Gehen Sie zu Teameinstellungen> Nachrichtenarchiv. Wählen Sie die Registerkarte "Exportieren" und dann "Export starten". Gemäß den Informationen auf dieser Seite wird eine Datei erstellt, die aus "einer Reihe von JSON-Dateien besteht: eine pro Kanal und Tag mit Aktivität sowie eine Datei mit Informationen zu allen Mitgliedern Ihres Teams".

Es wird einige Zeit dauern, bis Slack diesen Export vorbereitet hat, insbesondere wenn Sie viel Nachrichtenverkehr und Medien in den Kanälen haben (es werden auch Bilder exportiert). Nach einiger Zeit werden Sie per E-Mail darüber informiert, dass der Export zum Download bereitsteht.

Hier ist mein schnelles PHP-Skript, mit dem ich alle Sk-Kanäle lösche

<?php 
$json_url = "https://slack.com/api/channels.list?token=YOURTOKEN&pretty=1";
$json = file_get_contents($json_url);


$data = json_decode($json);
$m=count($data->channels);
echo "total channels:".$m."<br>";

$k=0;

for($i=0; $i<$m; $i++) {

//echo $data->channels[$i]->name."<br>";
$cn=$data->channels[$i]->name;
$cn2=$data->channels[$i]->is_archived;

if (strpos($cn, 'sk-') !== false and $cn2==0) {
   echo $data->channels[$i]->name."(".$cn2.") (id=";
   $cid=$data->channels[$i]->id;
   echo $cid.');<br>';

$json_url2 = "https://slack.com/api/channels.archive?token=YOURTOKEN&channel=".$cid."&pretty=1";
$json2 = file_get_contents($json_url2);
++$k;
}

}
echo "total sk channels archived:".$k."<br>";

?>

Hier ist ein Kotlin-Skript, das ich kürzlich geschrieben habe, um alle Kanäle zu archivieren, in denen seit 3 ​​Monaten keine neue Nachricht mehr enthalten war.

Hinweis: Wenn Sie das API-Limit in den Protokollen erreicht haben, warten Sie 2 Minuten und führen Sie es erneut aus.

import com.squareup.moshi.Moshi
import khttp.get
import java.time.ZonedDateTime

data class JsonChannelsList(
        val channels: List<JsonChannel>
)

data class JsonChannel(
        val id: String,
        val name_normalized: String,
        val is_archived: Boolean,
        val is_private: Boolean
)

data class JsonMessages(
        val messages: List<JsonMessage>
)

data class JsonMessage(
        val username: String,
        val text: String,
        val ts: String
)

data class ArchiveableChannel(
        val id: String,
        val name: String
)

/**
 * Arg 0 is your slack api token with user access (to be able to read channels)
 */
fun main(args: Array<String>) {
    val moshi = Moshi.Builder().build()
    val jsonChannelsAdapter = moshi.adapter(JsonChannelsList::class.java)
    val jsonMessagesAdapter = moshi.adapter(JsonMessages::class.java)

    val slackToken = args[0]

    val list = get("https://slack.com/api/channels.list?token=$slackToken&exclude_archived=true&pretty=1")

    val jsonChannelsList: JsonChannelsList = jsonChannelsAdapter.fromJson(list.jsonObject.toString()) as JsonChannelsList;
    println("${list.statusCode} - ${list.jsonObject}")
    val channels = jsonChannelsList.channels
    val archivable = arrayListOf<ArchiveableChannel>()

    println("Finding Archiveable Channels")
    for (c in channels) {
        println("Channel ${c.name_normalized} ")
        if (c.is_private) {
            println("private, skipped.")
            continue
        }
        if (c.is_archived) {
            println("archived already.")
            continue
        }
        val channelId = c.id;
        val THREE_MONTHS_AGO = ZonedDateTime.now().minusMonths(3).toEpochSecond()
        val msgs = get("https://slack.com/api/channels.history?token=$slackToken&channel=$channelId&oldest=$THREE_MONTHS_AGO&count=1")
//        print("messages ")
//        println(msgs.jsonObject)

        val jsonMessages: JsonMessages = jsonMessagesAdapter.fromJson(msgs.jsonObject.toString()) as JsonMessages
        if (jsonMessages.messages.isEmpty()) {
            archivable.add(ArchiveableChannel(c.id, c.name_normalized))
        }
    }

    println("Archive Channels")
    for (archiveChannel in archivable) {
        println(archiveChannel)
        val archivedResult = get("https://slack.com/api/channels.archive?token=$slackToken&channel=${archiveChannel.id}&pretty=1")
        print("${archivedResult.statusCode} ")
        print("${archiveChannel.name} ")
        print("${archivedResult.jsonObject}.")
    }
    println("done.")
    println("Archived ${archivable.size} channels.")
    println("Archived $archivable")
}

Erforderliche Abhängigkeiten:

compile "org.jetbrains.kotlin:kotlin-stdlib:1.0.3"
compile 'khttp:khttp:0.1.0'
compile("com.squareup.moshi:moshi-kotlin:1.8.0")

Quellprojekt hier: https://github.com/novoda/spikes/tree/master/slackdeath

Sie können hierfür spri.me (schamloser Stecker) verwenden. Anmelden, Kanäle auswählen und "Archivieren".