FilesExpand file tree

 messagequeue-quickfix

/

paymentbot.py

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

146 lines (114 loc) · 5.53 KB

 messagequeue-quickfix

/

paymentbot.py

Copy path

Top

File metadata and controls

• Code
• Blame

146 lines (114 loc) · 5.53 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

#!/usr/bin/env python

# -*- coding: utf-8 -*-

#

# Basic example for a bot that can receive payment from user.

# This program is dedicated to the public domain under the CC0 license.

from telegram import (LabeledPrice, ShippingOption)

from telegram.ext import (Updater, CommandHandler, MessageHandler,

Filters, PreCheckoutQueryHandler, ShippingQueryHandler)

import logging

# Enable logging

logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.INFO)

logger = logging.getLogger(__name__)

def error(bot, update, error):

logger.warn('Update "%s" caused error "%s"' % (update, error))

def start_callback(bot, update):

msg = "Use /shipping to get an invoice for shipping-payment, "

msg += "or /noshipping for an invoice without shipping."

update.message.reply_text(msg)

def start_with_shipping_callback(bot, update):

chat_id = update.message.chat_id

title = "Payment Example"

description = "Payment Example using python-telegram-bot"

# select a payload just for you to recognize its the donation from your bot

payload = "Custom-Payload"

# get your provider_token at @botfather, see https://core.telegram.org/bots/payments#getting-a-token

provider_token = "PROVIDER_TOKEN"

start_parameter = "test-payment"

currency = "USD"

# price in dollars

price = 1

# price * 100 so as to include 2 d.p.

# check https://core.telegram.org/bots/payments#supported-currencies for more details

prices = [LabeledPrice("Test", price * 100)]

# optionally pass need_name=True, need_phone_number=True,

# need_email=True, need_shipping_address=True, is_flexible=True

bot.sendInvoice(chat_id, title, description, payload,

provider_token, start_parameter, currency, prices,

need_name=True, need_phone_number=True,

need_email=True, need_shipping_address=True, is_flexible=True)

def start_without_shipping_callback(bot, update):

chat_id = update.message.chat_id

title = "Payment Example"

description = "Payment Example using python-telegram-bot"

# select a payload just for you to recognize its the donation from your bot

payload = "Custom-Payload"

# get your provider_token at @botfather, see https://core.telegram.org/bots/payments#getting-a-token

provider_token = "PROVIDER_TOKEN"

start_parameter = "test-payment"

currency = "USD"

# price in dollars

price = 1

# price * 100 so as to include 2 d.p.

prices = [LabeledPrice("Test", price * 100)]

# optionally pass need_name=True, need_phone_number=True,

# need_email=True, need_shipping_address=True, is_flexible=True

bot.sendInvoice(chat_id, title, description, payload,

provider_token, start_parameter, currency, prices)

def shipping_callback(bot, update):

query = update.shipping_query

# check the payload, is this from your bot?

if query.invoice_payload != 'Custom-Payload':

# answer False pre_checkout_query

bot.answer_shipping_query(shipping_query_id=query.id, ok=False,

error_message="Something went wrong...")

return

else:

options = list()

# a single LabeledPrice

options.append(ShippingOption('1', 'Shipping Option A', [LabeledPrice('A', 100)]))

# an array of LabeledPrice objects

price_list = [LabeledPrice('B1', 150), LabeledPrice('B2', 200)]

options.append(ShippingOption('2', 'Shipping Option B', price_list))

bot.answer_shipping_query(shipping_query_id=query.id, ok=True,

shipping_options=options)

# after (optional) shipping, it's the pre-checkout

def precheckout_callback(bot, update):

query = update.pre_checkout_query

# check the payload, is this from your bot?

if query.invoice_payload != 'Custom-Payload':

# answer False pre_checkout_query

bot.answer_pre_checkout_query(pre_checkout_query_id=query.id, ok=False,

error_message="Something went wrong...")

else:

bot.answer_pre_checkout_query(pre_checkout_query_id=query.id, ok=True)

# finally, after contacting to the payment provider...

def successful_payment_callback(bot, update):

# do something after successful receive of payment?

update.message.reply_text("Thank you for your payment!")

def main():

# Create the EventHandler and pass it your bot's token.

updater = Updater(token="BOT_TOKEN")

# Get the dispatcher to register handlers

dp = updater.dispatcher

# simple start function

dp.add_handler(CommandHandler("start", start_callback))

# Add command handler to start the payment invoice

dp.add_handler(CommandHandler("shipping", start_with_shipping_callback))

dp.add_handler(CommandHandler("noshipping", start_without_shipping_callback))

# Optional handler if your product requires shipping

dp.add_handler(ShippingQueryHandler(shipping_callback))

# Pre-checkout handler to final check

dp.add_handler(PreCheckoutQueryHandler(precheckout_callback))

# Success! Notify your user!

dp.add_handler(MessageHandler(Filters.successful_payment, successful_payment_callback))

# log all errors

dp.add_error_handler(error)

# Start the Bot

updater.start_polling()

# Run the bot until you press Ctrl-C or the process receives SIGINT,

# SIGTERM or SIGABRT. This should be used most of the time, since

# start_polling() is non-blocking and will stop the bot gracefully.

updater.idle()

if __name__ == '__main__':

main()