सर्वर रहित बर्थडे स्लैकबॉट एडब्ल्यूएस चालिस और अपस्टैश रेडिस के साथ

कभी-कभी अपने वार्षिक कार्यक्रमों के लिए रिमाइंडर बनाना सबसे अच्छा होता है ताकि आप उन विशेष तिथियों को न भूलें और याद रखें।

अगर आप और आपकी टीम/मित्र स्लैक का उपयोग कर रहे हैं, तो यह एक अच्छा विचार है कि आप इन रिमाइंडर को स्लैकबॉट्स के माध्यम से स्वचालित करें।

ऐसा करते समय, यदि आप चाहते हैं कि आपका स्लैकबॉट उसमें कम रखरखाव वाला हो; स्रोत के साथ समवर्ती इंटरैक्शन के लिए सर्वर रहित तकनीकों का उपयोग करना सबसे अच्छा हो सकता है, क्षैतिज मापनीयता को भी सक्षम करना।

हम क्या बना रहे हैं

हम एक ईवेंट रिमाइंडर स्लैकबॉट का निर्माण कर रहे हैं होस्टिंग के लिए पायथन, एडब्ल्यूएस चालिस, एडब्ल्यूएस लैम्ब्डा और एपीआई गेटवे का उपयोग करना। यह उपयोगकर्ताओं को सक्षम करेगा:

उपयोगकर्ताओं के लिए जन्मदिन सेट करें।
उपयोगकर्ताओं के लिए वर्षगाँठ सेट करें।
उपयोगकर्ताओं या सामान्य चैनल के लिए कस्टम ईवेंट सेट करें

एक बार ईवेंट सेट हो जाने पर:

लोगों को याद दिलाता है कि एक विशिष्ट ईवेंट आ रहा है, केवल उस व्यक्ति को छोड़कर जो ईवेंट के केंद्र में है (वह व्यक्ति जिसका उल्लेख ईवेंट सेट करते समय किया गया था)।
इवेंट की सालगिरह आने पर सामान्य चैनल पर पोस्ट, इवेंट के केंद्र में मौजूद व्यक्ति (या चैनल के सभी लोगों) का उल्लेख करते हुए।

कमांड

सेट

/event set birthday <YYYY-MM-DD> <user>

उपयोगकर्ता का जन्मदिन सेट करता है।
/event set anniversary <YYYY-MM-DD> <user>

उपयोगकर्ता के लिए वर्षगांठ सेट करता है, जब उन्होंने वहां काम करना शुरू किया।
/event set custom <YYYY-MM-DD> <user> <any kind of message with whitespaces>

प्रदान किए गए संदेश का उपयोग करके एक कस्टम रिमाइंडर सेट करता है।

गेट-ऑल

/event get-all :

सेट किए गए सभी ईवेंट दिखाता है।
/event get-all birthday :

सेट किए गए सभी जन्मदिन दिखाता है।
/event get-all anniversary :

सेट की गई सभी वर्षगाँठ दिखाता है।
/event get-all custom :

सेट किए गए सभी कस्टम ईवेंट दिखाता है।

प्राप्त करें

/event get birthday <user> :

उपयोगकर्ता के जन्मदिन का विवरण दिखाता है।
/event get anniversary <user> :

उपयोगकर्ता के लिए वर्षगांठ विवरण दिखाता है, जब उन्होंने वहां काम करना शुरू किया था।
/event get custom <event_name>(can be found with get-all) :

प्रदान किए गए संदेश का उपयोग करके कस्टम ईवेंट विवरण दिखाता है।

निकालें

/event remove birthday <user> :

उपयोगकर्ता का जन्मदिन हटा देता है।
/event remove anniversary <user> :

उपयोगकर्ता के लिए वर्षगाँठ को हटा देता है, जब उन्होंने वहां काम करना शुरू किया।
/event remove custom <event_name>(can be found with get-all) :

प्रदान किए गए संदेश का उपयोग करके कस्टम ईवेंट को निकालता है।

अनुसूचित अनुस्मारक

सामान्य चैनल को याद दिलाएं

समय आने पर, स्लैकबॉट निर्दिष्ट चैनल को रिमाइंडर संदेश भेजेगा।
बॉट से निजी संदेश

समय आने पर, स्लैकबॉट निजी रिमाइंडर संदेश भेजेगा।

इसलिए, इस टूल का उपयोग टीम के सदस्यों के लिए विशेष तिथियों पर नज़र रखने के लिए किया जा सकता है। इस तरह, संबंधों और अंतर-संचार को स्वस्थ तरीके से बनाए रखा जा सकता है।

आरंभ करना

डेटाबेस तैयार करें

हम Upstash कंसोल पर अपना Redis डेटाबेस बना सकते हैं। UPSTASH_REDIS_REST_URL और UPSTASH_REDIS_REST_TOKEN पर ध्यान दें क्योंकि वे AWS के लिए पर्यावरण चर होंगे।

AWS क्रेडेंशियल कॉन्फ़िगर करना

(आधिकारिक चालीस रेपो से लिया गया। आप वहां अधिक जानकारी के लिए देख सकते हैं।)

$ mkdir ~/.aws
$ cat >> ~/.aws/config
[default]
aws_access_key_id=YOUR_ACCESS_KEY_HERE
aws_secret_access_key=YOUR_SECRET_ACCESS_KEY
region=YOUR_REGION (such as us-west-2, us-west-1, etc)

कुछ कन्वेंशन

सभी .py app.py . के बाहर की फ़ाइलें chalicelib . के अंतर्गत रखा जाना चाहिए निर्देशिका, अन्यथा आयात विवरण समस्याएँ पैदा कर सकते हैं।
सभी पर्यावरण चरों को config.json में कॉन्फ़िगर किया जाना चाहिए .chalice . के अंदर फ़ाइल करें निर्देशिका।
- json प्रारूप में, कुंजी के साथ:"environment_variables"

प्रोजेक्ट सोर्स डेवलपमेंट

सबसे पहले, चूंकि हम AWS Chalice का उपयोग कर रहे हैं , चालीसा स्थापित करने के लिए:

pip install chalice

चालीस परियोजना आरंभ करें

chalice new-project <project_name> सर्वर रहित बर्थडे स्लैकबॉट एडब्ल्यूएस चालिस और अपस्टैश रेडिस के साथ फिर, cd प्रोजेक्ट फोल्डर में। प्रोजेक्ट पहले से ही एक टेम्प्लेट के साथ आता है।

भागो:chalice local यह देखने के लिए कि परियोजना काम करती है।

app.py

समग्र परियोजना संरचना और सुस्त अनुरोधों को संभालने के लिए मुख्य फ़ाइल।

<ब्लॉकक्वॉट>

इसके साथ, हम अपनी परियोजना संरचना और समापन बिंदु बनाते हैं। हम तय करते हैं कि इवेंट को कैसे हैंडल करना है, रिमाइंडर के काम करने के लिए क्या शेड्यूल करना है।

from chalice import Chalice, Cron, Rate
import os
import random
from datetime import date
from chalicelib.utils import responseToDict, postToChannel, diffWithTodayFromString, allSlackUsers, sendDm, validateRequest, convertToCorrectMention
from chalicelib.upstash import setHandler, getAllHandler, getEvent, getAllKeys, removeEvent

app = Chalice(app_name='birthday-slackbot')
NOTIFY_TIME_LIMIT = int(os.getenv("NOTIFY_TIME_LIMIT"))


# Sample route for get requests.
@app.route('/', methods=["GET"])
def something():
    return {
        "Hello": "World"
        }

# Configuring POST request endpoint.
# Command is parsed and handled/directed to handler
@app.route('/', methods=["POST"], content_types=["application/x-www-form-urlencoded"])
def index():

    # Parse the body for ease of use
    r = responseToDict(app.current_request.raw_body)
    headers = app.current_request.headers

    # Check validity of the request.
    if not validateRequest(headers, r):
        return {"Status": "Validation failed."}


    commandArray = r['text'].split()
    command = commandArray.pop(0)

    try:
        if command == "set":
            setHandler(commandArray)
            return {
            'response_type': "ephemeral",
            'text': "Set the event."
            }

        elif command == "get":
            eventType = commandArray[0]
            eventName = eventType + "-" + commandArray[1]
            resultDict = getEvent(eventName)
            return {
            'response_type': "ephemeral",
            'text': "`{}` Details:\n\n Date: {}\nRemaining: {} days!".format(eventName, resultDict[0], resultDict[1])
            }

        elif command == "get-all":

            stringResult = getAllHandler(commandArray)
            return {
            'response_type': "ephemeral",
            'text': "{}".format(stringResult)
            }

        elif command == "remove":
            eventName = "{}-{}".format(commandArray[0], commandArray[1])
            removeEvent(eventName)
            return {
            'response_type': "ephemeral",
            'text': "Removed the event."
            }
        else:
            return {
            'response_type': "ephemeral",
            'text': "Wrong usage of the command."
            }
    except:
        print("some stuff")
        return {
            'response_type': "ephemeral",
            'text': "Some problem occured. Please check your command."
        }


# Run at 10:00 am (UTC) every day.
@app.schedule(Cron(0, 10, '*', '*', '?', '*'))
def periodicCheck(event):
    allKeys = getAllKeys()
    for key in allKeys:
        handleEvent(key)


# Generic event is parsed and directed to relevant handlers.
def handleEvent(eventName):
    eventSplitted = eventName.split('-')

    eventType = eventSplitted[0]

    # discard @ or ! as a first character
    personName = eventSplitted[1][1:]
    personMention = convertToCorrectMention(personName)

    eventDict = getEvent(eventName)
    remainingDays = eventDict[1]
    totalTime = eventDict[2]


    if eventType == "birthday":
        birthdayHandler(personMention, personName, remainingDays)

    elif eventType == "anniversary":
        anniversaryHandler(personMention, personName, remainingDays, totalTime)

    elif eventType == "custom":
        eventMessage = "Not specified"
        if len(eventSplitted) == 3:
            eventMessage = eventSplitted[2]
        customHandler(eventMessage, personMention, personName, remainingDays)

# Handles birthday events.
def birthdayHandler(personMention, personName, remainingDays):
    if remainingDays == 0:
        sendRandomBirthdayToChannel('general', personMention)
    if remainingDays <= NOTIFY_TIME_LIMIT:
        dmEveryoneExcept("{} day(s) until {}'s birthday!".format(remainingDays, personMention), personName)

# Handles anniversary events.
def anniversaryHandler(personMention, personName, remainingDays, totalTime):
    if remainingDays == 0:
        sendRandomAnniversaryToChannel('general', personMention, totalTime)
    if remainingDays <= NOTIFY_TIME_LIMIT:
        dmEveryoneExcept("{} day(s) until {}'s anniversary! It will be {} year(s) since they joined!".format(remainingDays, personMention, totalTime), personName)

# Handles custom events.
def customHandler(eventMessage, personMention, personName, remainingDays):
    if remainingDays == 0:
        postToChannel('general', "`{}` is here {}!".format(eventMessage, personMention))
    elif remainingDays <= NOTIFY_TIME_LIMIT:
        dmEveryoneExcept("{} day(s) until {} `{}`!".format(remainingDays, personMention, eventMessage), personName)


# Sends private message to everyone except for the person given.
def dmEveryoneExcept(message, person):
    usersAndIds = allSlackUsers()
    for user in usersAndIds:
        if user[0] != person:
            sendDm(user[1], message)


# Sends randomly chosen birthday message to specified channel.
def sendRandomBirthdayToChannel(channel, personMention):
    messageList = [
        "Happy Birthday {}! Wishing you the best!".format(personMention),
        "Happy Birthday {}! Wishing you a happy age!".format(personMention),
        "Happy Birthday {}! Wishing you a healthy, happy life!".format(personMention),
    ]
    message = random.choice(messageList)
    return postToChannel('general', message)

# Sends randomly chosen anniversary message to specified channel.
def sendRandomAnniversaryToChannel(channel, personMention, totalTime):
    messageList = [
        "Today is the anniversary of {} joining! It has been {} years since they joined!".format(personMention, totalTime - 1),
        "Celebrating the anniversary of {} joining! It has been {} years!".format(personMention, totalTime - 1),
        "Congratulating {} for entering {}(th) year here!".format(personMention, totalTime),
    ]
    message = random.choice(messageList)
    return postToChannel('general', message)


# We want to run our event handlers when the project is deployed/redeployed.
allKeys = getAllKeys()
for key in allKeys:
    handleEvent(key)

chalicelib/utils.py

सहायक कार्यों और अमूर्तता के लिए मुख्य फ़ाइल।

<ब्लॉकक्वॉट>

हम मुख्य रूप से इस फाइल का उपयोग एब्स्ट्रैक्शन के लिए करेंगे। इसलिए, हमारा स्रोत कोड अव्यवस्थित नहीं होगा और पठनीयता बनाए रखेगा।

from urllib import request
import urllib
from urllib.parse import parse_qsl
import json
import os
import hmac
import hashlib
from datetime import date


SLACK_BOT_TOKEN = os.getenv("SLACK_BOT_TOKEN")
SLACK_SIGNING_SECRET = os.getenv("SLACK_SIGNING_SECRET")

# Returns real name of the slack user.
def getRealName(slackUsers, username):
    for user in slackUsers:
        if user[0] == username:
            return user[2]
    return "Nameless"

# Returns all slack users in the workspace.
def allSlackUsers():
    resultDict = sendPostRequest("https://slack.com/api/users.list", SLACK_BOT_TOKEN)
    members = resultDict['members']

    userMembers = []
    for member in members:
        if not member['deleted'] and not member['is_bot']:
            userMembers.append([member['name'], member['id'], member['real_name']])

    return userMembers

# Returns the id of the given channel.
def channelNameToId(channelName) :
    resultDict = sendPostRequest("https://slack.com/api/conversations.list", SLACK_BOT_TOKEN)
    for channel in resultDict['channels']:
        if (channel['name'] == channelName):
            return channel['id']
    return None

# Posts to given slack channelId with given message.
def postToSlack(channelId, messageText):
    data = {
        "channel": channelId,
        "text": messageText
    }
    data = json.dumps(data)
    data = str(data)
    data = data.encode('utf-8')
    resultDict = sendPostRequest("https://slack.com/api/chat.postMessage", SLACK_BOT_TOKEN, data)
    return resultDict

# Posts to a slack channel.
def postToChannel(channel, messageText):
    channelId = channelNameToId(channel)
    return postToSlack(channelId, messageText)

# Sends a private message to a user with userId.
def sendDm(userId, messageText):
    return postToSlack(userId, messageText)

# Sends generic post request and returns the result.
def sendPostRequest(requestURL, bearerToken, data={}):
    req = request.Request(requestURL, method="POST", data=data)
    req.add_header("Authorization", "Bearer {}".format(bearerToken))
    req.add_header("Content-Type", "application/json; charset=utf-8")

    r = request.urlopen(req)
    resultDict = json.loads(r.read().decode())
    return resultDict

# Parses and converts the res to dict.
def responseToDict(res):
    return dict(parse_qsl(res.decode()))


# Dates are given as: YYYY-MM-DD
# Returns difference between current day and the anniversary.
def diffWithTodayFromString(dateString):
    now = date.today()
    currentYear = now.year

    dateTokens = dateString.split("-")
    month = int(dateTokens[1])
    day = int(dateTokens[2])

    if now > date(currentYear, month, day):
        return (date((currentYear + 1), month, day) - now).days
    return (date(currentYear, month, day) - now).days


# Dates are given as: YYYY-MM-DD
# Calculates the total time that has passed until current date.
def totalTimefromString(dateString):
    now = date.today()

    dateTokens = dateString.split("-")
    year = int(dateTokens[0])
    month = int(dateTokens[1])
    day = int(dateTokens[2])

    then = date(year, month, day)

    years = now.year - then.year
    return years + 1

# Validate requests coming to endpoint.
# Hashes request body with timestamp and signing secret.
# Then, compares that hash with slack signature.
def validateRequest(header, body):

    bodyAsString = urllib.parse.urlencode(body)

    timestamp = header['x-slack-request-timestamp']
    slackSignature = header['x-slack-signature']
    baseString = "v0:{}:{}".format(timestamp, bodyAsString)

    h =  hmac.new(SLACK_SIGNING_SECRET.encode(), baseString.encode(), hashlib.sha256)
    hashResult = h.hexdigest()
    mySignature = "v0=" + hashResult

    return mySignature == slackSignature

# Converts given name to mention string.
def convertToCorrectMention(name):
    if name == "channel" or name == "here" or name == "everyone":
        return "<!{}>".format(name)
    else:
        return "<@{}>".format(name)

chalicelib/upstash.py

डेटाबेस से सीधे संबंधित कार्यों के लिए मुख्य फ़ाइल।

<ब्लॉकक्वॉट>

यहां, हम अपने डेटाबेस कॉल्स को हैंडल करेंगे। हम डेटाबेस से प्राप्त करेंगे, कुंजी-मूल्य जोड़े आदि सेट करेंगे। यह फ़ाइल हमें app.py से निम्न स्तर के विवरणों को सार करने में भी मदद करती है। , पठनीयता और प्रतिरूपकता को बढ़ाना।

अपस्टैश रेडिस डेटाबेस के बारे में एक बड़ी बात यह है कि यह रेस्टफुल एपीआई कॉल का समर्थन करता है। इस तरह, आप लगातार कनेक्शन बनाने और बंद करने की आवश्यकता के बिना अपने डेटाबेस तक पहुंच सकते हैं, जो सर्वर रहित अनुप्रयोगों के लिए जाने का तरीका है।

from chalicelib.utils import sendPostRequest, getRealName, allSlackUsers, diffWithTodayFromString, totalTimefromString
import os

UPSTASH_REST_URL = os.getenv("UPSTASH_REST_URL")
UPSTASH_TOKEN = os.getenv("UPSTASH_TOKEN")

# Posts to Upstash Rest Url with parameters given.
def postToUpstash(parameters):
    requestURL = UPSTASH_REST_URL
    for parameter in parameters:
        requestURL += ("/" + parameter)

    resultDict = sendPostRequest(requestURL, UPSTASH_TOKEN)
    return resultDict['result']


# Sets key-value pair for the event with given parameters.
def setEvent(parameterArray):

    postQueryParameters = ['SET']

    for parameter in parameterArray:
        parameter = parameter.split()
        for subparameter in parameter:
            postQueryParameters.append(subparameter)

    resultDict = postToUpstash(postQueryParameters)

    return resultDict


# Returns event details from the event given.
def getEvent(eventName):
    postQueryParameters = ['GET', eventName]
    date = postToUpstash(postQueryParameters)

    timeDiff = diffWithTodayFromString(date)
    totalTime = totalTimefromString(date)
    mergedDict = [date, timeDiff, totalTime]
    return mergedDict

# Fetches all keys (events) from the database
def getAllKeys():
    return postToUpstash(['KEYS', '*'])

# Deletes given event from the database.
def removeEvent(eventName):
    postQueryParameters = ['DEL', eventName]
    resultDict = postToUpstash(postQueryParameters)
    return resultDict


# Handles set request by parsing and configuring setEvent function parameters.
def setHandler(commandArray):
    eventType = commandArray.pop(0)
    date = commandArray.pop(0)
    user = commandArray.pop(0)

    if eventType == "birthday":
        listName = "birthday-" + user
        return setEvent( [listName, date] )

    elif eventType == "anniversary":
        listName = "anniversary-" + user
        return setEvent( [listName, date] )

    elif eventType == "custom":
        message = ""
        for string in commandArray:
            message += string + "_"

        listName = "custom-" + user + "-" + message
        user = commandArray[1]
        return setEvent( [listName, date] )
    else:
        return

# Handles get-all requests.
def getAllHandler(commandArray):
    filterParameter = None
    if len(commandArray) == 1:
        filterParameter = commandArray[0]

    allKeys = getAllKeys()
    birthdays = []
    anniversaries = []
    customs = []

    slackUsers = allSlackUsers()

    stringResult = "\n"
    for key in allKeys:
        if key[0] == 'b':
            birthdays.append(key)
        elif key[0] == 'a':
            anniversaries.append(key)
        elif key[0] == 'c':
            customs.append(key)

    if filterParameter is None or filterParameter == "birthday":
        stringResult += "Birthdays:\n"
        for bday in birthdays:
            tag = bday.split('-')[1]
            username = tag[1:]
            realName = getRealName(slackUsers, username)
            details = getEvent(bday)

            stringResult += "`{}` ({}): {} - `{} days` remaining!\n".format(tag, realName, details[0], details[1])

    if filterParameter is None or filterParameter == "anniversary":
        stringResult += "\nAnniversaries:\n"
        for ann in anniversaries:
            tag = ann.split('-')[1]
            username = tag[1:]
            realName = getRealName(slackUsers, username)
            details = getEvent(ann)

            stringResult += "`{}` ({}): {} - `{} days` remaining!\n".format(tag, realName, details[0], details[1])

    if filterParameter is None or filterParameter == "custom":
        stringResult += "\nCustom Reminders:\n"
        for cstm in customs:
            splitted = cstm.split('-')
            username = splitted[2]
            realName = getRealName(slackUsers, username)
            details = getEvent(cstm)

            stringResult += "`{}-{}` ({}): {}\n".format(splitted[1], splitted[2], getRealName(slackUsers, username), details[0])

    return stringResult

.chalice/config.json

एडब्ल्यूएस पर परियोजना के विन्यास के लिए फाइल।

<ब्लॉकक्वॉट>

यहां, हम अपने प्रोजेक्ट विवरण जैसे पर्यावरण चर और परिनियोजन चरणों को परिभाषित करते हैं। इसके लिए, हम केवल पर्यावरण चरों को जोड़कर कॉन्फ़िगर करेंगे:

{
  "environment_variables": {
    "UPSTASH_REST_URL": <UPSTASH_REDIS_REST_URL>,
    "UPSTASH_TOKEN": <UPSTASH_REDIS_REST_TOKEN>,
    "SLACK_BOT_TOKEN": <SLACK_BOT_TOKEN>,
    "SLACK_SIGNING_SECRET": <SLACK_SIGNING_SECRET>,
    "NOTIFY_TIME_LIMIT": "<amount of days before getting notifications for events>"
    }
}

आखिरकार हो गया

फ़ोल्डर संरचना

आपकी फोल्डर संरचना कुछ इस तरह दिखनी चाहिए:

<project_name>:
    app.py

    chalicelib:
        utils.py
        upstash.py
        <Some other default files generated by chalice>

    .chalice:
        config.json
        <Some other default files generated by chalice>

स्थानीय रूप से चल रहा है

<ब्लॉकक्वॉट>

चालीसा स्थानीय परिनियोजन के लिए सक्षम बनाता है, जो विकास प्रक्रिया को वास्तव में त्वरित बनाता है।

रन:chalice local सर्वर रहित बर्थडे स्लैकबॉट एडब्ल्यूएस चालिस और अपस्टैश रेडिस के साथ

यदि आपके पास एक स्थिर IP पता नहीं है, तो आपको एक टनलिंग सेवा का उपयोग करना चाहिए जैसे कि ngrok ताकि आप स्लैक को अपना समापन बिंदु दिखा सकें:

<ब्लॉकक्वॉट>

./ngrok http 8000 --> आपके लोकलहोस्ट को टनल करता है:8000 सर्वर रहित बर्थडे स्लैकबॉट एडब्ल्यूएस चालिस और अपस्टैश रेडिस के साथ

स्लैक कॉन्फ़िगर करें

1. स्लैक एपीआई ऐप्स पेज पर जाएं:

नया ऐप बनाएं
- स्क्रैच से
- अपने ऐप को नाम दें और कार्यक्षेत्र चुनें
शपथ और अनुमतियों पर जाएं
- निम्न दायरे जोड़ें
  - चैनल:पढ़ें
  - चैट:लिखें
  - चैट:लिखें.सार्वजनिक
  - आदेश
  - समूह:पढ़ें
  - उपयोगकर्ता:पढ़ें
- कार्यक्षेत्र में ऐप इंस्टॉल करें
  - बुनियादी जानकारी -> अपना ऐप इंस्टॉल करें -> कार्यक्षेत्र में इंस्टॉल करें

चरों पर ध्यान दें (ये AWS परिनियोजन के लिए env चर होंगे):
- SLACK_SIGNING_SECRET :
  - बुनियादी जानकारी पर जाएं
    - ऐप क्रेडेंशियल -> साइनिंग सीक्रेट
- SLACK_BOT_TOKEN :
  - OAuth और अनुमतियों पर जाएं
    - Bot उपयोगकर्ता OAuth टोकन

3. Slack API Apps पेज पर जाएं और प्रासंगिक ऐप चुनें:

परिनियोजन के बाद, आप REST_API_URL . का उपयोग कर सकते हैं या ngrok_domain <domain> के रूप में ।

Slack API Apps पेज पर जाएं और प्रासंगिक ऐप चुनें:

स्लैश कमांड पर जाएं:
- नई कमांड बनाएं:
  - कमांड:event
  - अनुरोध URL:<domain>
  - बाकी को अपनी पसंद के अनुसार कॉन्फ़िगर करें।

इन बदलावों के बाद, स्लैक को ऐप को फिर से इंस्टॉल करना पड़ सकता है।

बधाई हो!

अब आपके पास एक कार्यशील सर्वर रहित Slackbot है! बेझिझक इसे अपनी पसंद के अनुसार अनुकूलित करें।

स्थानीय होस्टिंग और परिणामों से संतुष्ट होने के बाद, बस:

chalice deploy एडब्ल्यूएस लैम्ब्डा और एपीआई गेटवे पर अंतिम तैनाती के लिए।

अब आप अपने स्लैक कॉन्फ़िगरेशन पर AWS चालिस द्वारा प्रदान किए गए REST_API_URL का उपयोग कर सकते हैं।

सर्वर रहित बर्थडे स्लैकबॉट एडब्ल्यूएस चालिस और अपस्टैश रेडिस के साथ

हम क्या बना रहे हैं

कमांड

सेट

गेट-ऑल

प्राप्त करें

निकालें

अनुसूचित अनुस्मारक

सामान्य चैनल को याद दिलाएं

बॉट से निजी संदेश

आरंभ करना

डेटाबेस तैयार करें

AWS क्रेडेंशियल कॉन्फ़िगर करना

कुछ कन्वेंशन

प्रोजेक्ट सोर्स डेवलपमेंट

चालीस परियोजना आरंभ करें

app.py

chalicelib/utils.py

chalicelib/upstash.py

.chalice/config.json

आखिरकार हो गया

फ़ोल्डर संरचना

आपकी फोल्डर संरचना कुछ इस तरह दिखनी चाहिए:

स्थानीय रूप से चल रहा है

स्लैक कॉन्फ़िगर करें

1. स्लैक एपीआई ऐप्स पेज पर जाएं:

3. Slack API Apps पेज पर जाएं और प्रासंगिक ऐप चुनें:

बधाई हो!

पूरे प्रोजेक्ट के लिए, आप Github रेपो पर जा सकते हैं।