示例#1
0
func init() {
	opt = new(telebot.SendOptions)
	flag.StringVar(&iniFile, "ini", "", "Specify php.ini path")
	flag.StringVar(&tokenFile, "t", "token", "File contains bot token")
	flag.StringVar(&phpFile, "php", "entry.php", "PHP entry file, you can access JSON encoded message data in $message")
	flag.UintVar(&workers, "w", 1, "Run `N` goroutines to process message, must greater than 0")
	flag.Parse()

	data, err := ioutil.ReadFile(tokenFile)
	if err != nil {
		log.Fatalf("Cannot read token from file[%s]: %s", tokenFile, err)
	}
	token = strings.TrimSpace(string(data))

	if workers < 1 {
		flag.PrintDefaults()
		os.Exit(1)
	}

	if _, err := os.Stat(phpFile); err != nil {
		log.Fatalf("PHP entry file %s error: %s", phpFile, err)
	}

	bot, err = telebot.NewBot(token)
	if err != nil {
		log.Fatalf("Cannot start telebot: %s", err)
	}

	pipe = make(chan task)
}
示例#2
0
func main() {
	flag.Parse()
	if *token_file == "" {
		flag.PrintDefaults()
		os.Exit(1)
	}

	args := flag.Args()
	log.Print(args)
	if len(args) < 1 {
		log.Fatal(`Usage: ` + os.Args[0] + ` -worker 5 -token=token_file cmd_to_run arg1 arg2 ...`)
	}

	token, err := ioutil.ReadFile(*token_file)
	if err != nil {
		log.Fatal(err)
	}

	bot, err := telebot.NewBot(string(token))
	if err != nil {
		log.Fatal(err)
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	h := CreateHandler(bot, args, *max_worker)
	log.Printf("Workers: %d\n", *max_worker)

	for msg := range messages {
		go h.Process(bot, msg)
	}
}
示例#3
0
// bot execution logic, init logic
func main() {
	bot, err := telebot.NewBot(os.Getenv("TELEGRAM_TOKEN"))
	if err != nil {
		fmt.Println("Fatal(0x0): Unable to start bot")
		return
	}

	data_map = make(map[string]BotData)
	msg_map = make(map[string]string)
	data, err := ioutil.ReadFile("msg.txt")
	if err != nil {
		fmt.Println("Fatal(0x1): Unable to read msg file")
		return
	}

	err = json.Unmarshal(data, &msg_map)
	if err != nil {
		fmt.Println("Fatal(0x2): Unable to parse msg file")
		return
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	fmt.Println("Info(0x0): Now listening")

	for msg := range messages {
		handler(bot, msg)
	}
}
示例#4
0
func RunTelegramBot() {
	if GetConfiguration().Notification.TelegramBotApiKey == "" {
		return
	}

	bot, err := telebot.NewBot(GetConfiguration().Notification.TelegramBotApiKey)
	if err != nil {
		logging.MustGetLogger("").Error("Unable to start Telegram-Bot: ", err)
		return
	}
	logging.MustGetLogger("").Info("Telgram-Bot started.")
	Bot = bot

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {
		if message.Text == "/start" {
			bot.SendMessage(message.Chat, "Welcome to the UpAndRunning2 Telegram-Bot! \U0001F44B\n\nPlease use your User-ID (`"+strconv.Itoa(message.Sender.ID)+"`) as notification-target in UpAndRunning2.", &SendOptions)
		} else if message.Text == "/id" {
			bot.SendMessage(message.Chat, "Your User-ID: `"+strconv.Itoa(message.Sender.ID)+"`", &SendOptions)
		} else if message.Text == "/server" {
			bot.SendMessage(message.Chat, "This server is running *UpAndRunning2 v"+GetConfiguration().Static.Version+"* (`"+GetConfiguration().Static.GoVersion+"@"+GetConfiguration().Static.GoArch+"`).\n"+
				"You can find more information about this application [here](https://github.com/MarvinMenzerath/UpAndRunning2).\n\n"+
				"*Server-Settings:*\n    - Title: `"+GetConfiguration().Application.Title+"`\n    - Interval: `"+strconv.Itoa(GetConfiguration().Dynamic.Interval)+"`\n"+
				"    - Redirects: `"+strconv.Itoa(GetConfiguration().Application.RedirectsToFollow)+"`\n    - Offline-Checks: `"+strconv.FormatBool(GetConfiguration().Application.RunCheckIfOffline)+"`", &SendOptions)
		}
	}
}
示例#5
0
func OpenBot(name string) (*Bot, error) {

	rand.Seed(time.Now().UTC().UnixNano())
	file, err := os.Open(name)
	if err != nil {
		return nil, err
	}

	defer file.Close()

	var bot *Bot

	err = json.NewDecoder(file).Decode(&bot)
	if err != nil {
		return nil, err
	}

	bot.Bot, err = telebot.NewBot(bot.Token)
	if err != nil {
		log.Fatal(err)
	} else {
		log.Printf("Bot " + bot.Name + " started!")
	}

	return bot, err
}
示例#6
0
// NewBot creates a Bots with token `token`, which is a secret API key assigned to particular bot.
func NewBot(token string) (*Bot, error) {
	bot, err := telebot.NewBot(token)
	if err != nil {
		return nil, errors.New("Failed to create a bot!")
	}

	return &Bot{token, false, bot, make(chan telebot.Message), make(map[string]*Task)}, nil
}
示例#7
0
文件: main.go 项目: nubunto/fixr
func main() {
	// the token on which telebot will send/receive stuff
	var token = flag.String("token", "", "The bot token")

	// the address and port on which redis will listen
	var redis = flag.String("redis", "localhost:6379", "The address to bind to redis, e.g. \"localhost:5555\"")

	// the cron string on which to send all the currencies (why I did this?)
	var cronString = flag.String("cron", "0 0 9 * * *", "The cron string on which to send currencies.")

	// the filename of the log when on the server (this is good)
	var output = flag.String("output", "", "The file where to create the log")

	flag.Parse()

	bot, err := telebot.NewBot(*token)

	// if telegram is not there, bail.
	if err != nil {
		panic(err)
	}

	fixrAccessor := fixrdb.New("tcp", *redis)

	defer fixrAccessor.Close()

	// if there's a file, create it and use it. Else, assume debugging: pipe to stdout.
	if len(*output) > 0 {
		output, err := os.Create(*output)
		if err != nil {
			panic(err)
		}
		logging.Start(output)
	} else {
		logging.Start(os.Stdout)
	}

	// this doesn't actually work... but whatever.
	defer func() {
		logging.Info("Stopping the program")
	}()

	logging.Info("Started Redis instance")

	// start the scheduler
	startSched(bot, fixrAccessor, *cronString)
	messages := make(chan telebot.Message)
	done := make(chan bool)

	// listen to updates
	bot.Listen(messages, 1*time.Second)

	// handle messages on a different goroutine, so we don't mess this up.
	go handleMessages(messages, bot, fixrAccessor, done)

	// wait for the inevitable end (that never comes)
	<-done
}
示例#8
0
// Initialize Telegram adapter
func (adapter *Telegram) Init() error {
	bot, err := telebot.NewBot(adapter.cfg.Token)
	if err != nil {
		return err
	}

	adapter.bot = bot
	return nil
}
示例#9
0
文件: main.go 项目: nicluo/jarvisbot
func main() {
	// Grab current executing directory
	// In most cases it's the folder in which the Go binary is located.
	pwd, err := osext.ExecutableFolder()
	if err != nil {
		log.Fatalf("error getting executable folder: %s", err)
	}
	configJSON, err := ioutil.ReadFile(path.Join(pwd, "config.json"))
	if err != nil {
		log.Fatalf("error reading config file! Boo: %s", err)
	}

	var config map[string]string
	json.Unmarshal(configJSON, &config)

	telegramAPIKey, ok := config["telegram_api_key"]
	if !ok {
		log.Fatalf("config.json exists but doesn't contain a Telegram API Key! Read https://core.telegram.org/bots#3-how-do-i-create-a-bot on how to get one!")
	}
	botName, ok := config["name"]
	if !ok {
		log.Fatalf("config.json exists but doesn't contain a bot name. Set your botname when registering with The Botfather.")
	}

	bot, err := telebot.NewBot(telegramAPIKey)
	if err != nil {
		log.Fatalf("error creating new bot, dude %s", err)
	}

	logger := log.New(os.Stdout, "[jarvis] ", 0)

	jb := jarvisbot.InitJarvis(botName, bot, logger, config)
	defer jb.CloseDB()

	jb.AddFunction("/laugh", jb.SendLaugh)
	jb.AddFunction("/neverforget", jb.NeverForget)
	jb.AddFunction("/touch", jb.Touch)
	jb.AddFunction("/hanar", jb.Hanar)
	jb.AddFunction("/ducks", jb.SendImage("quack quack m**********r"))
	jb.AddFunction("/chickens", jb.SendImage("cluck cluck m**********r"))

	jb.GoSafely(func() {
		logger.Println("Scheduling exchange rate update")
		for {
			time.Sleep(1 * time.Hour)
			jb.RetrieveAndSaveExchangeRates()
			logger.Printf("[%s] exchange rates updated!", time.Now().Format(time.RFC3339))
		}
	})

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {
		jb.Router(message)
	}
}
示例#10
0
文件: main.go 项目: nicluo/morningbot
func main() {
	// Grab current executing directory
	// In most cases it's the folder in which the Go binary is located.
	pwd, err := osext.ExecutableFolder()
	if err != nil {
		log.Fatalf("error getting executable folder: %s", err)
	}
	configJSON, err := ioutil.ReadFile(path.Join(pwd, "config.json"))
	if err != nil {
		log.Fatalf("error reading config file! Boo: %s", err)
	}

	var config map[string]string
	json.Unmarshal(configJSON, &config)

	telegramAPIKey, ok := config["telegram_api_key"]
	if !ok {
		log.Fatalf("config.json exists but doesn't contain a Telegram API Key! Read https://core.telegram.org/bots#3-how-do-i-create-a-bot on how to get one!")
	}
	botName, ok := config["name"]
	if !ok {
		log.Fatalf("config.json exists but doesn't contain a bot name. Set your botname when registering with The Botfather.")
	}

	bot, err := telebot.NewBot(telegramAPIKey)
	if err != nil {
		log.Fatalf("error creating new bot, %s", err)
	}

	logger := log.New(os.Stdout, "[morningbot] ", 0)

	logger.Printf("Args: %s %s %s", botName, bot, logger)

	mb := morningbot.InitMorningBot(botName, bot, logger, config)
	defer mb.CloseDB()

	mb.GoSafely(func() {
		logger.Println("Scheduling Time Check")
		for {
			nextHour := time.Now().Truncate(time.Hour).Add(time.Hour)
			timeToNextHour := nextHour.Sub(time.Now())
			time.Sleep(timeToNextHour)
			logger.Printf("[%s] [%s] !", time.Now().Format(time.RFC3339), time.Now().Hour())
			if time.Now().Hour() == 7 {
				mb.MorningCall()
			}
		}
	})

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {
		mb.Router(message)
	}
}
示例#11
0
func main() {
	var msg, country string
	flag.Parse()
	if *token_file == "" {
		flag.PrintDefaults()
		os.Exit(1)
	}
	token, err := ioutil.ReadFile(*token_file)
	if err != nil {
		log.Fatal(err)
	}
	bot, err := telebot.NewBot(string(token))
	if err != nil {
		return
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {
		// pretty.Println(message.Sender)
		msg = message.Text
		if msg == "/hi" {
			count := 1
			for {
				pretty.Println(count)
				count++
				bot.SendMessage(message.Chat,
					"Hello, "+message.Sender.FirstName+"!", nil)
				time.Sleep(1000 * time.Millisecond)
			}
		} else if strings.HasPrefix(msg, "/flag") {
			//check if flag is empty
			country = "ASEAN" //msg[6:]
			pretty.Print(country)
			photo := "./resources/flags/" + country + ".png"
			boom, err := telebot.NewFile(photo)
			if err != nil {
				pretty.Print(err)
			}
			pretty.Print(&bot)
			pretty.Print(&boom)

			// SendPhoto
			// telebot.File{}ASEAN&telebot.File{FileID:"", FileSize:0, filename:"./resources/flags/ASEAN.png"}
			// pretty.Print(reflect.TypeOf((*bot).SendMessage))
			// // get from directory
			// err = bot.SendAudio(message.Chat, &boom, nil)
			// err = bot.SendMessage(message.Chat, &boom, nil)
			if err != nil {
				pretty.Print(err)
			}
		}
	}
}
示例#12
0
func main() {

	var c int
	var configurationFile = "telegram-config.json"
	var logFile string
	OptErr = 0
	for {
		if c = Getopt("c:l:h"); c == EOF {
			break
		}
		switch c {
		case 'c':
			configurationFile = OptArg
		case 'l':
			logFile = OptArg
		case 'h':
			println("usage: " + os.Args[0] + " [-c configfile.json|-l logfile|-h]")
			os.Exit(1)
		}
	}

	config, err := util.LoadConfig(configurationFile)

	if logFile != "" {
		//Set logging to file
		f, err := os.OpenFile(logFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
		if err != nil {
			log.Fatal("error opening file: %v", err)
		}
		defer f.Close()

		log.SetOutput(f)
	}

	bot, err := telebot.NewBot(config.Token)
	if config.Token != "" {
		fmt.Println("Token: " + config.Token)
	}
	fmt.Println("Configuration file: " + configurationFile)
	fmt.Println("Log file: " + logFile)

	if err != nil {
		return
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {
		for _, d := range plugin_registry.Plugins {
			go d.Run(bot, config, message)
		}
	}
}
示例#13
0
文件: bot.go 项目: grishin/djigurbot
func main() {
	telegramAPIKey := os.Getenv("DJIGURBOT_TELEGRAMAPIKEY")
	if telegramAPIKey == "" {
		panic("Telegram api key is not set.")
	}

	bot, err := telebot.NewBot(telegramAPIKey)
	if err != nil {
		panic("Could not connect to Telegram API")
	}

	toasts, err := readToastsFile()
	if err != nil {
		panic("Could not read toasts.txt file")
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {
		if message.Text == "/hi" {
			bot.SendMessage(message.Chat,
				"Привет, "+message.Sender.FirstName+"!", nil)
		} else if strings.Contains(message.Text, "Тост!") {
			randomToast := toasts[rand.Intn(len(toasts))]
			bot.SendMessage(message.Chat, randomToast.Text, nil)
		} else if strings.Contains(strings.ToLower(message.Text), "костя") {
			bot.SendMessage(message.Chat, "Костя крутой!", nil)
		} else if strings.Contains(strings.ToLower(message.Text), "твоя!") {
			bot.SendMessage(message.Chat, "Нееееет, твоя!", nil)
		} else if strings.Contains(strings.ToLower(message.Text), "крутой") {
			bot.SendMessage(message.Chat, "Нееееет, "+message.Sender.FirstName+", это ты крутой!", nil)
		} else if strings.Contains(strings.ToLower(message.Text), "сокиабле") {
			bot.SendMessage(message.Chat, "Сокиабле? ЧОБЛЯ?", nil)
		} else if strings.Contains(strings.ToLower(message.Text), "доброе утро") {
			bot.SendMessage(message.Chat, "И тебе наидобрейшего утра, "+message.Sender.FirstName+"!", nil)
		} else if strings.Contains(strings.ToLower(message.Text), "поздравляй!") {
			bot.SendMessage(message.Chat, `С 8 марта поздравляем вас, коллеги,
От души хотим вам пожелать,
Чтоб совместные победы и успехи
Дали нам возможность процветать!
Чтоб в делах житейских и в работе
Находить умели компромисс,
Одевались по последней моде,
Были леди, то бишь миссис или мисс.
Чтобы было нам в кого влюбляться,
Чтобы было нас кому любить,
Молодыми вечно оставаться
и насыщенной веселой жизнью жить!`, nil)
		}

	}
}
示例#14
0
func newbot(c *cli.Context) {
	var err error
	theBot, err = telebot.NewBot(c.String("tgtoken"))
	if err != nil {
		println(err.Error())
		os.Exit(TG_ERROR)
	}
	theBot.Messages = make(chan telebot.Message, 1000)
	theBot.Queries = make(chan telebot.Query, 1000)
	go messages()
	go queries()
	theBot.Start(1 * time.Second)
}
示例#15
0
文件: bot.go 项目: Supro/fitbot
func GetBotInstance() *bot {
	bot_once.Do(func() {
		cfg := GetConfigurationInstance()

		tb, err := telebot.NewBot(cfg.TelegramKey)
		if err != nil {
			log.Fatal(err)
		}

		bot_instance = &bot{Connection: tb}
	})

	return bot_instance
}
示例#16
0
文件: bot.go 项目: Kimau/GoCam
func startBot() *Cambot {
	var err error
	var cb Cambot

	cb.bot, err = telebot.NewBot(TELEGRAM_SECRET_TOKEN)
	if err != nil {
		return nil
	}

	cb.messages = make(chan telebot.Message)
	cb.bot.Listen(cb.messages, REFRESH_TIME)

	go cb.ProceessMessage()

	return &cb
}
示例#17
0
func main() {
	bot, err := telebot.NewBot("124223052:AAGr9lxL0Ewi50jBzEDSKy36d_Rxh-g5pUg")
	if err != nil {
		return
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {
		if message.Text == "/hi" {
			bot.SendMessage(message.Chat,
				"Hello, "+message.Sender.FirstName+"!", nil)
		}
	}
}
示例#18
0
文件: main.go 项目: ruqqq/nuswherebot
func main() {
	bot, err := telebot.NewBot(os.Getenv("TELEGRAM_SECRET"))
	if err != nil {
		panic(err)
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	fmt.Println("Bot started.")

	// Message handler
	for message := range messages {
		if message.Text == "/help" || message.Text == "/start" {
			bot.SendMessage(message.Chat, "Hello, "+message.Sender.FirstName+"! To get the location of a place in NUS, just type the keywords of the place you're looking for.", nil)
		} else {
			// Perform case insensitive search and remove bot mention in case it's a mention
			locations, err := getLocationInfoNUS(strings.Replace(strings.ToLower(message.Text), strings.ToLower(BOT_NICK)+" ", "", 1))
			if len(locations) != 0 && err != nil {
				bot.SendMessage(message.Chat, "Oops! I encountered an error while searching for the location you requested. Please try again later.", nil)
				fmt.Printf("Error while retrieving location: %s\n", err.Error())
				continue
			}

			if len(locations) == 0 {
				bot.SendMessage(message.Chat, "Oops! I cannot find any result with your search query.", nil)
				continue
			}

			for _, location := range locations {
				bot.SendMessage(message.Chat, "Location found! Sending you the map...", nil)
				photo, err := getLocationMap(location)
				if err != nil {
					bot.SendMessage(message.Chat, "Oops! I encountered an error while searching for the location you requested. Please try again later.", nil)
					fmt.Printf("Error while retrieving map: %s\n", err.Error())
					continue
				}

				bot.SendPhoto(message.Chat, photo, nil)
			}
		}

		// Keep track of number of requests (no particular reason to)
		requestCount++
		fmt.Printf("Total Requests: %d\n", requestCount)
	}
}
示例#19
0
文件: web.go 项目: worg/hookah
func processHook(ctx webhooks.Context) {
	h := ctx.Hook()
	branch := strings.TrimPrefix(h.Ref, `refs/heads/`)

	for _, r := range cfg.Repos {
		go func(r repo) {
			if r.Name != h.Repo.Name ||
				(r.Branch != `*` && r.Branch != branch) {
				return
			}

			go r.Tasks.Run() //execute tasks
			if r.Notify.Telegram.ChatID != 0 &&
				r.Notify.Telegram.Token != `` {
				var (
					buf bytes.Buffer
					bot *telebot.Bot
					err error
				)

				err = tmpl.Execute(&buf, map[string]interface{}{
					`hook`:   h,
					`branch`: branch,
				})
				if err != nil {
					log.Println(`Template ERR:`, err)
					return
				}

				if bot, err = telebot.NewBot(r.Notify.Telegram.Token); err != nil {
					log.Println(`Telegram ERR:`, err)
					return
				}

				err = bot.SendMessage(telebot.User{ID: r.Notify.Telegram.ChatID}, buf.String(), &sendOpts)
				if err != nil {
					log.Println(`Telegram ERR:`, err)
					return
				}

				log.Println(`Message Sent`)
			}
		}(r)
	}
}
示例#20
0
文件: bot.go 项目: vickydasta/gists
func main() {
	bot, err := telebot.NewBot(botToken)
	if err != nil {
		return
	}
	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)
	for message := range messages {
		if message.Text == "stat" {
			uptime := cmd("uptime")
			bot.SendMessage(message.Chat, uptime, nil)
		}
		if message.Text == "dir" {
			ls := cmd("ls")
			bot.SendMessage(message.Chat, ls, nil)
		}
	}
}
示例#21
0
func NewHerald(token string) (*Herald, error) {
	bot, err := telebot.NewBot(token)
	if err != nil {
		return nil, err
	}

	h := &Herald{bot: bot}
	h.Handlers = map[string]Handler{
		"/hi":   h.RegisterUser,
		"/help": h.GetUsage,
		"/kill": h.KillCommand,
		"/log":  h.GetOutput,
		//	"/stats":  ,
		"/who": h.GetUsers,
	}

	return h, nil
}
示例#22
0
文件: main.go 项目: Xe/trolling
func main() {
	bot, err := telebot.NewBot(os.Getenv("TELEGRAM_TOKEN"))
	if err != nil {
		panic(err)
	}

	bot.Messages = make(chan telebot.Message, 1000)
	bot.Queries = make(chan telebot.Query, 1000)

	go inlineHandler(bot)
	go func() {
		for message := range bot.Messages {
			if message.Text == "/start" {
				log.Printf("%s %d signed up for Printer Facts", message.Sender.Username, message.Sender.ID)
				bot.SendMessage(message.Chat, "Hello human. I am a printer facts bot. Inline me to get printer facts.\n\nIf you are having trouble with cached facts, type in some random garbage in after @printerfacts.", nil)
			}
		}
	}()

	bot.Start(1 * time.Second)
}
示例#23
0
文件: doofus.go 项目: nf/doofus
func main() {
	rand.Seed(time.Now().UnixNano())

	cards, err := mtgprice.Open(mtgprice.Opts{Filename: "mtgprice.kv", CardData: "AllCards.json"})
	if err != nil {
		log.Fatal("loading cards:", err)
	}
	closeOnTerm(cards)

	bot, err := telebot.NewBot(os.Getenv("TOKEN"))
	if err != nil {
		log.Fatal(err)
	}
	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Minute)

	for msg := range messages {
		if err := handleMessage(cards, bot, msg); err != nil {
			log.Printf("Error handling message %v: %v", msg, err)
		}
	}
}
示例#24
0
func main() {
	rand.Seed(time.Now().UTC().UnixNano())
	dictData, err := ioutil.ReadFile("dict.txt")
	if err != nil {
		logger.Fatal(err)
	}
	dict := strings.Split(string(dictData), "\n")

	SecretAPIKey := os.Getenv(BotApiKey)
	if SecretAPIKey == "" {
		logger.Fatalf("env variable %s not specifited", BotApiKey)
	}
	bot, err := telebot.NewBot(SecretAPIKey)
	if err != nil {
		logger.Fatal(err)
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)
	sendOptions := telebot.SendOptions{
		ReplyMarkup: telebot.ReplyMarkup{
			ForceReply: true,
			Selective:  true,

			CustomKeyboard: [][]string{
				[]string{"Совет Гуру"},
			},
		},
	}
	for message := range messages {
		logger.Printf("Req %s from user %s ", message.Text, message.Sender.FirstName)
		if message.Text == "/start" {
			bot.SendMessage(message.Chat, "Привет, я раскажу тебе как двигать тазом, "+message.Sender.FirstName+"!", &sendOptions)
		} else {
			bot.SendMessage(message.Chat, processGeneralMessage(message.Text, dict), &sendOptions)
		}
	}
}
示例#25
0
func main() {
	start := util.TimestampMS()
	// Connect to Telegram
	var err error
	bot, err = telebot.NewBot(*token)
	if err != nil {
		log.Fatalf("Error connecting to Telegram: %[1]s", err)
		return
	}
	messages := make(chan telebot.Message)
	// Enable message listener
	bot.Listen(messages, 1*time.Second)
	// Print "connected" message
	log.Infof("Successfully connected to Telegram!")

	// Update timetables
	timetables.Update()

	go posts.Loop(bot, *debug)
	go laundry.Loop(bot)
	go listen(bot)

	startedAt = time.Now()

	var startup = "Ranssibot started up"
	if *debug {
		startup = fmt.Sprintf("Ranssibot started up in %[1]dms @ %[2]s (Debug mode)", util.TimestampMS()-start, startedAt.Format("15:04:05 02.01.2006"))
	}

	log.Infof(startup)
	onoffspam(startup)

	// Listen to messages
	for message := range messages {
		go handleCommand(bot, message)
	}
}
示例#26
0
func main() {

	//init redis
	redisClient = redis.NewClient(&redis.Options{
		Addr:     "localhost:6379",
		Password: "",
		DB:       1,
	})

	dict.PrepareIndex()

	bot, err := telebot.NewBot(BOT_TOKEN)
	if err != nil {
		return
	}

	util.LogInit()

	messages := make(chan telebot.Message)
	bot.Listen(messages, 2*time.Second)

	for message := range messages {
		sender_id := message.Chat.ID

		// analytics purpose
		k := "u:" + strconv.Itoa(sender_id)
		redisClient.ZIncrBy("sorted_users", 1, k)

		definition := GetDefinition(message.Text, message.Chat)

		err = bot.SendMessage(message.Chat, definition, &telebot.SendOptions{ParseMode: "Markdown"})
		if err != nil {
			util.LogError("sendMessage", sender_id, err)
		}
	}
}
示例#27
0
文件: main.go 项目: gloob/gfxBot
func main() {
	// Load main configuration.
	usr, err := user.Current()
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(usr)
	//configFile := usr.HomeDir + "/.config/gfxbot/config.toml"
	configFile := "config.toml"
	err = gfxBot.LoadConfig(configFile, &globalConfig)
	if err != nil {
		log.Fatal(err)
	}

	bot, err := telebot.NewBot(globalConfig.Token)
	if err != nil {
		log.Fatal(err)
	}

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {
		fmt.Println(message)
		stathat.PostEZCount("gfxBot message processed", "*****@*****.**", 1)
		if message.Text == "/start" {
			bot.SendMessage(message.Chat, "This is a Telegram bot for searching images into different services.", nil)
		}
		if strings.HasPrefix(message.Text, "/duck") {
			bot.SendChatAction(message.Chat, telebot.Typing)
			duck := gfxBot.NewDuck()
			img, err := duck.Search(strings.TrimPrefix(strings.TrimPrefix(message.Text, "/duck"), "@gfxBot"))
			if err != nil {
				fmt.Println("Error in duck.Search()")
				fmt.Println(err)
				bot.SendMessage(message.Chat, fmt.Sprintf("%s", err), nil)
				continue
			}
			err = sendImage(bot, message, img)
			if err != nil {
				bot.SendMessage(message.Chat, fmt.Sprintf("%s", err), nil)
			}
		}
		if strings.HasPrefix(message.Text, "/flickr") {
			bot.SendChatAction(message.Chat, telebot.Typing)
			flickr := gfxBot.NewFlickr(globalConfig.FlickrAPIKey, globalConfig.FlickrAPISecret)
			img, err := flickr.Search(strings.TrimPrefix(strings.TrimPrefix(message.Text, "/flickr"), "@gfxBot"))
			if err != nil {
				fmt.Println("Error in flickr.Search()")
				fmt.Println(err)
				bot.SendMessage(message.Chat, fmt.Sprintf("%s", err), nil)
				continue
			}
			err = sendImage(bot, message, img)
			if err != nil {
				bot.SendMessage(message.Chat, fmt.Sprintf("%s", err), nil)
			}
		}
		if strings.HasPrefix(message.Text, "/instagram") {
			bot.SendChatAction(message.Chat, telebot.Typing)
			instagram := gfxBot.NewInstagram(globalConfig.InstagramAPIKey, globalConfig.InstagramAPISecret, globalConfig.InstagramAPIToken)
			img, err := instagram.Search(strings.TrimPrefix(strings.TrimPrefix(message.Text, "/instagram"), "@gfxBot"))
			if err != nil {
				fmt.Println("Error in instagram.Search()")
				fmt.Println(err)
				bot.SendMessage(message.Chat, fmt.Sprintf("%s", err), nil)
				continue
			}
			err = sendImage(bot, message, img)
			if err != nil {
				bot.SendMessage(message.Chat, fmt.Sprintf("%s", err), nil)
			}
		}
		if message.Text == "/help" {
			bot.SendMessage(message.Chat, "This is a Telegram bot for searching images into different services.", nil)
		}
	}
}
示例#28
0
func main() {
	token := flag.String("token", "", "The Telegram bot token")
	to := flag.String("to", "", "The mail recipient")
	from := flag.String("from", "", "The mail sender")
	server := flag.String("server", "", "The mail server")
	port := flag.Int("port", 587, "The mail server port")
	user := flag.String("user", "", "")
	pass := flag.String("pass", "", "")
	subject := flag.String("subject", "", "")

	flag.Parse()

	bot, err := telebot.NewBot(*token)
	if err != nil {
		return
	}

	// Fetching Mails and send as Telegram messages

	var (
		c   *imap.Client
		cmd *imap.Command
		rsp *imap.Response
	)

	c, _ = imap.Dial(*server)

	defer c.Logout(30 * time.Second)

	c.Data = nil

	if c.Caps["STARTTLS"] {
		c.StartTLS(nil)
	}

	if c.State() == imap.Login {
		c.Login(*user, *pass)
	}

	cmd, _ = imap.Wait(c.List("", "%"))

	c.Data = nil

	c.Select("INBOX", true)

	set, _ := imap.NewSeqSet("")
	set.Add("1:*")
	cmd, _ = c.Fetch(set, "RFC822.HEADER")

	for cmd.InProgress() {
		c.Recv(-1)

		for _, rsp = range cmd.Data {
			header := imap.AsBytes(rsp.MessageInfo().Attrs["RFC822.HEADER"])
			if msg, _ := mail.ReadMessage(bytes.NewReader(header)); msg != nil {
				fmt.Println("|--", msg.Header.Get("FROM"))
			}
		}
		cmd.Data = nil
		c.Data = nil
	}

	if rsp, err := cmd.Result(imap.OK); err != nil {
		if err == imap.ErrAborted {
			fmt.Println("Fetch command aborted")
		} else {
			fmt.Println("Fetch error:", rsp.Info)
		}
	}

	/*
	 * Listen to Telegram messages and send as mail
	 */

	messages := make(chan telebot.Message)
	bot.Listen(messages, 1*time.Second)

	for message := range messages {

		m := gomail.NewMessage()
		m.SetHeader("From", *from)
		m.SetHeader("To", *to)
		m.SetHeader("Subject", *subject)
		m.SetBody("text/html", message.Text)

		d := gomail.NewPlainDialer(*server, *port, *user, *pass)
		d.TLSConfig = &tls.Config{InsecureSkipVerify: true}

		if err := d.DialAndSend(m); err != nil {
			panic(err)
		}
	}
}