वर्तमान में हमारे पास ~ 8K संदेशों के साथ एक स्लैक चैनल है जो सभी जेनकिंस एकीकरण से आता है। क्या उस चैनल के सभी संदेशों को हटाने के लिए कोई प्रोग्रामेटिक तरीका है? वेब इंटरफ़ेस एक बार में केवल 100 संदेश हटा सकता है।
जवाबों:
मुझे जल्दी से पता चला कि कोई व्यक्ति पहले से ही एक सहायक बना हुआ है: इसके लिए सुस्त-क्लीनर ।
और मेरे लिए यह सिर्फ:
slack-cleaner --token=<TOKEN> --message --channel jenkins --user "*" --perform
--user "*"यह काम करने के लिए भी आवश्यक है। यदि आप वास्तव में निष्कासन कार्य करना चाहते हैं, तो भी आपको जोड़ना चाहिए --perform।
--quietकरने के लिए प्रदर्शित नहीं हर संदेश stdout पर हटाया जा रहा है।
मैंने सार्वजनिक / निजी चैनलों और चैट से संदेशों को हटाने के लिए एक सरल नोड स्क्रिप्ट लिखी। आप इसे संशोधित और उपयोग कर सकते हैं।
https://gist.github.com/firatkucuk/ee898bc919021da621689f5e47e7abac
सबसे पहले, स्क्रिप्ट कॉन्फ़िगरेशन अनुभाग में अपना टोकन संशोधित करें फिर स्क्रिप्ट चलाएँ:
node ./delete-slack-messages CHANNEL_ID
इसके अलावा, चैनल आईडी ब्राउज़र URL में देखी जा सकती है जब आप ब्राउज़र में सुस्त खोलते हैं। जैसे
https://mycompany.slack.com/messages/MY_CHANNEL_ID/
या
https://app.slack.com/client/WORKSPACE_ID/MY_CHANNEL_ID
निम्न त्रुटि देने के लिए डिफ़ॉल्ट क्लीन कमांड ने काम नहीं किया:
$ slack-cleaner --token=<TOKEN> --message --channel <CHANNEL>
Running slack-cleaner v0.2.4
Channel, direct message or private group not found
लेकिन बॉट संदेशों को साफ करने के लिए बिना किसी मुद्दे के बाद काम किया गया
slack-cleaner --token <TOKEN> --message --group <CHANNEL> --bot --perform --rate 1
या
slack-cleaner --token <TOKEN> --message --group <CHANNEL> --user "*" --perform --rate 1
सभी संदेशों को साफ करने के लिए।
मैं HTTP 429 Too Many Requestsसुस्त एपी दर सीमा के कारण त्रुटि से बचने के लिए 1 सेकंड की दर-सीमा का उपयोग करता हूं । दोनों मामलों में, चैनल का नाम बिना #हस्ताक्षर के आपूर्ति किया गया था
!!अपडेट करें!!
as @ niels-van-reijmersdal टिप्पणी में मिले थे।
यह सुविधा हटा दी गई है। अधिक जानकारी के लिए इस धागे को देखें: twitter.com/slackhq/status/467182697979588608?lang=en
!! END अपडेट !!
यहां ट्विटर में SlackHQ का एक अच्छा जवाब है, और यह किसी भी तीसरे पक्ष के सामान के बिना काम करता है। https://twitter.com/slackhq/status/467182697979588608?lang=en
आप किसी विशेष चैनल के लिए अभिलेखागार ( http://my.slack.com/archives ) पृष्ठ के माध्यम से हटा सकते हैं : मेनू में "हटाएं" देखें
किसी और के लिए जिसे इसे प्रोग्राम करने की आवश्यकता नहीं है, यहाँ एक त्वरित तरीका है :
(शायद केवल भुगतान किए गए उपयोगकर्ताओं के लिए)
मैं आमतौर पर चैनल को कुछ संदर्भ के साथ छोड़ने के लिए "1 दिन" के लिए यह विकल्प सेट करता हूं, फिर मैं उपरोक्त सेटिंग्स में वापस जाता हूं, और यह निर्धारित करता हूं कि अब से उन्हें स्टोर करना जारी रखने के लिए "डिफ़ॉल्ट" पर वापस अवधारण नीति है ।
नोट्स:
ल्यूक बताते हैं: यदि विकल्प छिपा हुआ है: आपको वैश्विक कार्यक्षेत्र में जाना होगा व्यवस्थापक सेटिंग्स, संदेश अवधारण और हटाएं, और जांचें "कार्यस्थान सदस्यों को इन सेटिंग्स को ओवरराइड करने दें"
विकल्प 1 आप 1 दिन के बाद संदेशों को स्वचालित रूप से हटाने के लिए एक स्लैक चैनल सेट कर सकते हैं, लेकिन यह थोड़ा छिपा हुआ है। सबसे पहले, आपको अपने स्लैक वर्कस्पेस सेटिंग, मैसेज रिटेंशन एंड डिलीटेशन पर जाना होगा, और "कार्यक्षेत्र के सदस्यों को इन सेटिंग्स को ओवरराइड करने दें" की जांच करनी होगी। उसके बाद, स्लैक क्लाइंट में आप एक चैनल खोल सकते हैं, गियर पर क्लिक कर सकते हैं, और "एडिट मैसेज रिटेंशन ..." पर क्लिक करें।
विकल्प 2 सुस्त-क्लीनर कमांड लाइन उपकरण जो दूसरों ने उल्लेख किया है।
विकल्प 3 नीचे एक छोटी सी स्क्रिप्ट है जिसे मैं निजी चैनलों को साफ करने के लिए उपयोग करता हूं। यदि आप विलोपन के अधिक प्रोग्रामेटिक नियंत्रण चाहते हैं तो एक अच्छा प्रारंभिक बिंदु हो सकता है। दुर्भाग्य से स्लैक में कोई बल्क-डिलीट एपीआई नहीं है, और वे अलग-अलग डिलीट को 50 प्रति मिनट तक सीमित करते हैं, इसलिए यह अपरिहार्य रूप से लंबा समय लेता है।
# -*- coding: utf-8 -*-
"""
Requirement: pip install slackclient
"""
import multiprocessing.dummy, ctypes, time, traceback, datetime
from slackclient import SlackClient
legacy_token = raw_input("Enter token of an admin user. Get it from https://api.slack.com/custom-integrations/legacy-tokens >> ")
slack_client = SlackClient(legacy_token)
name_to_id = dict()
res = slack_client.api_call(
"groups.list", # groups are private channels, conversations are public channels. Different API.
exclude_members=True,
)
print ("Private channels:")
for c in res['groups']:
print(c['name'])
name_to_id[c['name']] = c['id']
channel = raw_input("Enter channel name to clear >> ").strip("#")
channel_id = name_to_id[channel]
pool=multiprocessing.dummy.Pool(4) #slack rate-limits the API, so not much benefit to more threads.
count = multiprocessing.dummy.Value(ctypes.c_int,0)
def _delete_message(message):
try:
success = False
while not success:
res= slack_client.api_call(
"chat.delete",
channel=channel_id,
ts=message['ts']
)
success = res['ok']
if not success:
if res.get('error')=='ratelimited':
# print res
time.sleep(float(res['headers']['Retry-After']))
else:
raise Exception("got error: %s"%(str(res.get('error'))))
count.value += 1
if count.value % 50==0:
print(count.value)
except:
traceback.print_exc()
retries = 3
hours_in_past = int(raw_input("How many hours in the past should messages be kept? Enter 0 to delete them all. >> "))
latest_timestamp = ((datetime.datetime.utcnow()-datetime.timedelta(hours=hours_in_past)) - datetime.datetime(1970,1,1)).total_seconds()
print("deleting messages...")
while retries > 0:
#see https://api.slack.com/methods/conversations.history
res = slack_client.api_call(
"groups.history",
channel=channel_id,
count=1000,
latest=latest_timestamp,)#important to do paging. Otherwise Slack returns a lot of already-deleted messages.
if res['messages']:
latest_timestamp = min(float(m['ts']) for m in res['messages'])
print datetime.datetime.utcfromtimestamp(float(latest_timestamp)).strftime("%r %d-%b-%Y")
pool.map(_delete_message, res['messages'])
if not res["has_more"]: #Slack API seems to lie about this sometimes
print ("No data. Sleeping...")
time.sleep(1.0)
retries -= 1
else:
retries=10
print("Done.")
ध्यान दें, उस स्क्रिप्ट को सार्वजनिक चैनलों को सूचीबद्ध और साफ़ करने के लिए संशोधन की आवश्यकता होगी। उन लोगों के लिए एपीआई तरीके चैनल हैं। * समूहों के बजाय। *
युक्ति: यदि आप सुस्त क्लीनर https://github.com/kfei/slack-cleaner का उपयोग करने वाले हैं
आपको टोकन जनरेट करना होगा: https://api.slack.com/custom-integrations/legacy-tokens
अन्य उत्तरों के अनुसार, स्लैक की दर सीमाएं इस मुश्किल को कम करती हैं - दर सीमा उनके चैट के लिए अपेक्षाकृत कम है। एपीआई एपीआई ~ 50 अनुरोध प्रति मिनट।
सबसे अच्छी रणनीति जो दर सीमा का सम्मान करती है, वह उस चैनल से संदेश प्राप्त करना है जिसे आप साफ़ करना चाहते हैं, फिर 50 से कम के बैचों में उन संदेशों को हटा दें जो कि न्यूनतम अंतराल पर चलते हैं।
मैंने इस बैचिंग के एक उदाहरण के साथ एक परियोजना बनाई है जिसे आप आसानी से कांटा कर सकते हैं और ऑटोकोड पर तैनात कर सकते हैं - यह आपको स्लैश कमांड के माध्यम से एक चैनल को साफ़ करने देता है (और आपको कमांड को एक्सेस करने की अनुमति देता है! जब आप /cmd clearकिसी चैनल में चलते हैं , तो यह उस चैनल को क्लीयर करने के लिए चिह्नित करता है और हर मिनट में निम्नलिखित कोड चलाता है जब तक कि यह चैनल के सभी संदेशों को हटा नहीं देता है:
console.log(`About to clear ${messages.length} messages from #${channel.name}...`);
let deletionResults = await async.mapLimit(messages, 2, async (message) => {
try {
await lib.slack.messages['@0.6.1'].destroy({
id: clearedChannelId,
ts: message.ts,
as_user: true
});
return {
successful: true
};
} catch (e) {
return {
successful: false,
retryable: e.message && e.message.indexOf('ratelimited') !== -1
};
}
});
आप यहां अपना स्वयं का संस्करण तैनात करने के लिए पूर्ण कोड और एक मार्गदर्शिका देख सकते हैं: https://autocode.com/src/jacoblee/slack-clear-messages/
यदि आप पायथन को पसंद करते हैं और सुस्त एपीआई से एक विरासत एपीआई टोकन प्राप्त किया है , तो आप निम्नलिखित के साथ एक उपयोगकर्ता को भेजे गए सभी निजी संदेशों को हटा सकते हैं:
import requests
import sys
import time
from json import loads
# config - replace the bit between quotes with your "token"
token = 'xoxp-854385385283-5438342854238520-513620305190-505dbc3e1c83b6729e198b52f128ad69'
# replace 'Carl' with name of the person you were messaging
dm_name = 'Carl'
# helper methods
api = 'https://slack.com/api/'
suffix = 'token={0}&pretty=1'.format(token)
def fetch(route, args=''):
'''Make a GET request for data at `url` and return formatted JSON'''
url = api + route + '?' + suffix + '&' + args
return loads(requests.get(url).text)
# find the user whose dm messages should be removed
target_user = [i for i in fetch('users.list')['members'] if dm_name in i['real_name']]
if not target_user:
print(' ! your target user could not be found')
sys.exit()
# find the channel with messages to the target user
channel = [i for i in fetch('im.list')['ims'] if i['user'] == target_user[0]['id']]
if not channel:
print(' ! your target channel could not be found')
sys.exit()
# fetch and delete all messages
print(' * querying for channel', channel[0]['id'], 'with target user', target_user[0]['id'])
args = 'channel=' + channel[0]['id'] + '&limit=100'
result = fetch('conversations.history', args=args)
messages = result['messages']
print(' * has more:', result['has_more'], result.get('response_metadata', {}).get('next_cursor', ''))
while result['has_more']:
cursor = result['response_metadata']['next_cursor']
result = fetch('conversations.history', args=args + '&cursor=' + cursor)
messages += result['messages']
print(' * next page has more:', result['has_more'])
for idx, i in enumerate(messages):
# tier 3 method rate limit: https://api.slack.com/methods/chat.delete
# all rate limits: https://api.slack.com/docs/rate-limits#tiers
time.sleep(1.05)
result = fetch('chat.delete', args='channel={0}&ts={1}'.format(channel[0]['id'], i['ts']))
print(' * deleted', idx+1, 'of', len(messages), 'messages', i['text'])
if result.get('error', '') == 'ratelimited':
print('\n ! sorry there have been too many requests. Please wait a little bit and try again.')
sys.exit()
आपके कार्यक्षेत्र पर सभी सुस्त संदेशों को हटाने के लिए एक सुस्त उपकरण है। इसे देखें : https://www.messagebender.com
यहां आपके सुस्त चैनल / समूह / im संदेशों को हटाने के लिए एक महान क्रोम एक्सटेंशन है - https://slackext.com/deleter , जहां आप स्टार, समय सीमा या उपयोगकर्ताओं द्वारा संदेशों को फ़िल्टर कर सकते हैं। BTW, यह हाल के संस्करण में सभी संदेशों को लोड करने का भी समर्थन करता है, फिर आप अपने ~ 8k संदेशों को लोड कर सकते हैं जैसे आपको ज़रूरत है।