chirpnest/bot.go

package main

import (
	"encoding/json"
	"fmt"
	"log"
	"os"
	"regexp"
	"strconv"
	"time"

	tb "gopkg.in/tucnak/telebot.v2"
)

func BotHandlers(b *tb.Bot) {

	b.Handle("/test", botTest)
	b.Handle("/test_delay", botTestDelay)
	b.Handle("/test_html", botTestHTML)
	b.Handle("/test_user", botTestUser)

	b.Handle("/msg_rescan", botMsgRescan)
	b.Handle("/msg_rescan_all", botMsgRescanAll)
	b.Handle("/msg_dump", botMsgDump)

	b.Handle("/parse_rules", botListParsingRules)
	b.Handle("/parse_rule", botListParsingRule)

	b.Handle("/timer", botTimer)

	b.Handle("/g_deposit_all", botGDepositAll)
	b.Handle("/g_withdraw", botGWithdraw)
	b.Handle("/save_res", botSaveRes)

	b.Handle("/backup_export", botBackupExport)
	b.Handle("/backup_import", botBackupImport)

	b.Handle("/help", botHelp)

	b.Handle("/get_item_id", botGetItemId)
	b.Handle("/clients", botGetClients)

	b.Handle("/vault", botVaultHelp)
	b.Handle("/vault_all", botVaultAll)
	b.Handle("/vault_res", botVaultRes)
	b.Handle("/vault_alch", botVaultAlch)
	b.Handle("/vault_misc", botVaultMisc)
	b.Handle("/vault_rec", botVaultRec)
	b.Handle("/vault_part", botVaultPart)
	b.Handle("/vault_other", botVaultOther)
	b.Handle("/vault_item", botVaultItem)

	b.Handle("/restart_job", botRestartJob)
	b.Handle("/cleanup_job", botCleanupJob)

	b.Handle(tb.OnPhoto, botPhoto)
	b.Handle(tb.OnChannelPost, botChannelPost)
	b.Handle(tb.OnQuery, botQuery)
	b.Handle(tb.OnText, botText)
	b.Handle(tb.OnDocument, botDocument)

	b.Start()
}

func PrintText(m *tb.Message) {
	log.Printf("[%d] %s(%d) | %s(%d) : %s\n", m.ID, m.Chat.Title, m.Chat.ID, m.Sender.Username, m.Sender.ID, m.Text)
	return
}

func botPhoto(m *tb.Message) {
	fmt.Println("botPhoto :", m.Text)
	//	photos only
}

func botDocument(m *tb.Message) {
	fmt.Printf("botDocument : %s (%d bytes)\n", m.Document.FileName, m.Document.File.FileSize)
	//	documents only
}

func botChannelPost(m *tb.Message) {
	PrintText(m)
	b, _ := json.Marshal(m)
	log.Printf("botChannelPost : %s\n", string(b))

	//	channel posts only
}

func botQuery(q *tb.Query) {
	fmt.Println("botQuery")
	//	incoming inline queries
}

func botText(m *tb.Message) {
	PrintText(m)

	if m.Chat.ID == cfg.Bot.Depositchat && m.IsForwarded() && m.OriginalSender != nil && int64(m.OriginalSender.ID) == chtwrsbotID64 {
		cwm := ChatWarsMessage{
			TGUserID64:       int64(bot.Me.ID),
			TGSenderUserID64: int64(m.Sender.ID),
			ID64:             int64(m.ID),
			ChatID64:         int64(m.Chat.ID),
			Text:             m.Text,
			Date:             m.Time().UTC(),
			IsForwarded:      true,
		}
		MQCWMsgQueue <- cwm
	} else if m.IsForwarded() && m.OriginalSender != nil && int64(m.OriginalSender.ID) == chtwrsbotID64 {
		cwm := ChatWarsMessage{
			TGUserID64:       int64(m.Sender.ID),
			TGSenderUserID64: chtwrsbotID64,
			ID64:             int64(m.ID),
			ChatID64:         int64(m.Chat.ID),
			Text:             m.Text,
			Date:             m.Time().UTC(),
			IsForwarded:      true,
		}
		MQCWMsgQueue <- cwm
	} else if (m.Chat.ID == cfg.Bot.Depositchat || m.Chat.ID == cfg.Bot.Mainchat) && !m.IsForwarded() {
		cwm := ChatWarsMessage{
			TGUserID64:       int64(m.Sender.ID),
			TGSenderUserID64: int64(m.Sender.ID),
			ID64:             int64(m.ID),
			ChatID64:         int64(m.Chat.ID),
			Text:             m.Text,
			Date:             m.Time().UTC(),
			IsForwarded:      false,
		}
		MQCWMsgQueue <- cwm
	} else if m.Private() {
		cwm := ChatWarsMessage{
			TGUserID64:       int64(m.Sender.ID),
			TGSenderUserID64: int64(m.Sender.ID),
			ID64:             int64(m.ID),
			ChatID64:         int64(m.Chat.ID),
			Text:             m.Text,
			Date:             m.Time().UTC(),
			IsForwarded:      false,
		}
		MQCWMsgQueue <- cwm
	}
	// all the text messages that weren't
	// captured by existing handlers
}

func botHelp(m *tb.Message) {
	if !m.Private() {
		return
	}
	c := TGCommand{
		Type: commandReplyMsg,
		Text: `/help - this help
/msg_rescan <id> - rescan one message
/msg_rescan_all - rescan all messages
/msg_dump <id> - dump msg
/parse_rules - list parsing rules\n
/parse_rule <id> - detail for one rule
/timer <ETA> "msg" - schedule msg for client in ETA
/g_stock - check guild's vault
/backup_export - export message database
/backup_import <URL> - import message database from URL
/get_item_id <string> - identify item_id from string
/clients - list all connected clients
/g_deposit_all - deposit all res to vault
/g_withdraw <item> <qty> .. - withdraw items
/vault - Deposit and withdrawal stats`,
		FromMsgID64:  int64(m.ID),
		FromChatID64: m.Chat.ID,
	}
	TGCmdQueue <- c
	return
}

func botTestUser(m *tb.Message) {
	if !m.Private() {
		return
	}

	c, err := bot.ChatByID(m.Payload)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
			ParseMode:    cmdParseModeHTML,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         c.Username,
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
			ParseMode:    cmdParseModeHTML,
		}
		TGCmdQueue <- c
	}

	return
}

func botTestHTML(m *tb.Message) {
	if !m.Private() {
		return
	}
	c := TGCommand{
		Type: commandReplyMsg,
		Text: `<b>bold</b>,
<strong>bold</strong>,
<i>italic</i>,
<em>italic</em>,
<a href="https://t.me/share/url?url=/tu_def jgm2v8">inline URL</a>,
<code>inline fixed-width code</code>,
<pre>pre-formatted fixed-width code block</pre>`,
		FromMsgID64:  int64(m.ID),
		FromChatID64: m.Chat.ID,
		ParseMode:    cmdParseModeHTML,
	}
	TGCmdQueue <- c

	return
}

func botTest(m *tb.Message) {
	if !m.Private() {
		return
	}
	if clt, ok := getLockedClient(m.Chat.ID, false); ok {
		clt.Mux.Unlock()
		clientSendCWMsg(m.Chat.ID, "🏅Me")

		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Test sent",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}
	return
}

func botTestDelay(m *tb.Message) {
	if !m.Private() {
		return
	}
	if clt, ok := getLockedClient(m.Chat.ID, false); ok {
		clt.Mux.Unlock()
		clientSendCWMsgDelay(m.Chat.ID, "🏅Me", 5*time.Second)

		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Test sent",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}
	return
}

func botGetClients(m *tb.Message) {
	if !m.Private() {
		return
	}
	if clt, ok := getLockedClient(m.Chat.ID, false); ok {
		clt.Mux.Unlock()
		muxClients.RLock()
		ret := fmt.Sprintf("<code>Version %s (%s)\n", githash, buildstamp)
		for id, c := range clients {
			chat, err := bot.ChatByID(strconv.FormatInt(id, 10))
			logOnError(err, "botGetClients : ChatByID")
			var status string
			if c.Active {
				status = `online`
			} else {
				status = `offline`
			}
			ret = fmt.Sprintf("%s%s (%s) | @%s (%s)\n", ret, c.Login, c.Build, chat.Username, status)
		}
		ret = fmt.Sprintf("%s</code>", ret)
		muxClients.RUnlock()

		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         ret,
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
			ParseMode:    cmdParseModeHTML,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}
	return
}

func botMsgRescan(m *tb.Message) {
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()
	if clt.TGUserID64 != cfg.Bot.Admin {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Admin only",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	r := regexp.MustCompile("^[0-9]+$")
	if r.MatchString(m.Payload) {
		p := JobPayloadRescanMsg{
			Query:    fmt.Sprintf("SELECT o.id FROM obj o WHERE o.id = %s AND o.obj_type_id = %d AND o.obj_sub_type_id = %d;", m.Payload, cacheObjType[`msg`], cacheObjSubType[`msg`]),
			MsgID64:  int64(m.ID),
			ChatID64: m.Chat.ID,
		}
		b, _ := json.Marshal(p)
		log.Printf("botMsgRescan : json : %s\n", string(b))
		_, err := createJob(cacheObjSubType[`job_rescan_msg`], objJobPriorityRescanMsg, int64(m.Sender.ID), 0, time.Now().UTC(), b)
		logOnError(err, "botMsgRescan : createJob(cacheObjSubType[`job_rescan_msg`])")
		if err != nil {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         fmt.Sprintf("Error scheduling the rescan for msg #%s", m.Payload),
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
		} else {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         fmt.Sprintf("Rescaning msg #%s", m.Payload),
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
		}
	}
	r = regexp.MustCompile("^all$")
	if r.MatchString(m.Payload) {
		botMsgRescanAll(m)
	}
	return
}

func botMsgRescanAll(m *tb.Message) {
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()
	if clt.TGUserID64 != cfg.Bot.Admin {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Admin only",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}

	var p JobPayloadRescanMsg
	if len(m.Payload) > 0 {
		r := regexp.MustCompile("^\"(?P<Filter>(.*))\"$")
		if r.MatchString(m.Payload) {
			p.Query = fmt.Sprintf("SELECT o.id FROM obj o, obj_msg om WHERE o.obj_type_id = %d AND o.obj_sub_type_id = %d AND om.obj_id = o.id AND om.text like '%s' ORDER BY o.id ASC;", cacheObjType[`msg`], cacheObjSubType[`msg`], r.ReplaceAllString(m.Payload, "${Filter}"))
		} else {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         "Wrong format",
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
			return
		}
	} else {
		p.Query = fmt.Sprintf("SELECT o.id FROM obj o WHERE o.obj_type_id = %d AND o.obj_sub_type_id = %d ORDER BY o.id ASC;", cacheObjType[`msg`], cacheObjSubType[`msg`])
	}

	log.Printf("botMsgRescanAll : Query : %s\n", p.Query)
	p.MsgID64 = int64(m.ID)
	p.ChatID64 = m.Chat.ID

	b, _ := json.Marshal(p)
	_, err := createJob(cacheObjSubType[`job_rescan_msg`], objJobPriorityRescanAllMsg, int64(m.Sender.ID), 0, time.Now().UTC(), b)
	logOnError(err, "botMsgRescan : createJob(cacheObjSubType[`job_rescan_msg`])")

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Error scheduling the rescan for all msg.",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Rescaning all msg scheduled.",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}
	return
}

func botBackupExport(m *tb.Message) {
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()
	if clt.TGUserID64 != cfg.Bot.Admin {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Admin only",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}

	p := JobPayloadBackupExport{
		MsgID64:  int64(m.ID),
		ChatID64: m.Chat.ID,
	}
	b, _ := json.Marshal(p)
	_, err := createJob(cacheObjSubType[`job_backup_export`], objJobPriorityBackup, int64(m.Sender.ID), 0, time.Now().UTC(), b)
	logOnError(err, "botBackupExport : createJob(cacheObjSubType[`job_backup_export`])")

	return
}

func botBackupImport(m *tb.Message) {
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()
	if clt.TGUserID64 != cfg.Bot.Admin {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Admin only",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	/*
		r := regexp.MustCompile(`^((http[s]?\:)\/\/)?([^\?\:\/#]+)(\:([0-9]+))?(\/[^\?\#]*)?(\?([^#]*))?(#.*)?.zip$`)
		if !r.MatchString(m.Payload) {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         "URL not valid.",
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
			return
		}
	*/

	p := JobPayloadBackupImport{
		URL:      m.Payload,
		MsgID64:  int64(m.ID),
		ChatID64: m.Chat.ID,
	}
	b, _ := json.Marshal(p)
	_, err := createJob(cacheObjSubType[`job_backup_import`], objJobPriorityBackup, int64(m.Sender.ID), 0, time.Now().UTC(), b)
	logOnError(err, "botBackupImport : createJob(cacheObjSubType[`job_backup_import`])")
	return

}

func botMsgDump(m *tb.Message) {
	var res string
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()
	if clt.TGUserID64 != cfg.Bot.Admin {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Admin only",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}

	r := regexp.MustCompile("^[0-9]+$")
	if r.MatchString(m.Payload) {
		objId, _ := strconv.ParseInt(m.Payload, 10, 64)
		objTypeId, err := getObjTypeId(objId)
		logOnError(err, "botMsgDump : getObjSubTypeId")
		if err != nil {
			res = `Error retrieving the message`
		} else if objTypeId != cacheObjType[`msg`] {
			res = `This is not a message reference`
		} else {
			cwm, _ := getObjMsg(objId)
			b, _ := json.Marshal(cwm)
			res = string(b)
		}
	} else {
		res = `/msg_dump <msg_id>`
	}

	c := TGCommand{
		Type:         commandReplyMsg,
		Text:         res,
		FromMsgID64:  int64(m.ID),
		FromChatID64: m.Chat.ID,
	}
	TGCmdQueue <- c

	return
}

func botListParsingRules(m *tb.Message) {
	var s string = ""
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()
	if clt.TGUserID64 != cfg.Bot.Admin {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Admin only",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}

	for _, v := range msgParsingRules {
		s = fmt.Sprintf("%s[%d] %s\n", s, v.ID, v.Description)
		if len(s) > 3000 {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         s,
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
			s = ``
		}
	}

	c := TGCommand{
		Type:         commandReplyMsg,
		Text:         s,
		FromMsgID64:  int64(m.ID),
		FromChatID64: m.Chat.ID,
	}
	TGCmdQueue <- c
	return
}

func botListParsingRule(m *tb.Message) {
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()
	if clt.TGUserID64 != cfg.Bot.Admin {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Admin only",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	r := regexp.MustCompile("^[0-9]+$")
	if r.MatchString(m.Payload) {
		i, _ := strconv.ParseInt(m.Payload, 10, 64)
		for _, v := range msgParsingRules {
			if int64(v.ID) == i {
				c := TGCommand{
					Type:         commandReplyMsg,
					Text:         fmt.Sprintf("%s\n", v.Rule),
					FromMsgID64:  int64(m.ID),
					FromChatID64: m.Chat.ID,
				}
				TGCmdQueue <- c
				return
			}
		}
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("Could not find rule %s\n", m.Payload),
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("/parse_rule <id>\n"),
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}
	return
}

func botGStock(m *ChatWarsMessage) {
	if hasUnfinishedJob(cacheObjSubType[`job_gstock`]) {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "GStock is already running",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}

	clt, err := getLockedIdleClient()
	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Busy, please retry later.",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}
	userID64 := clt.TGUserID64
	clt.Mux.Unlock()

	p := JobPayloadGStock{
		MsgID64:  m.ID64,
		ChatID64: m.ChatID64,
		Status:   0,
	}
	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err = createJob(cacheObjSubType[`job_gstock`], objJobPriority, userID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Stock requested",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botShops(m *ChatWarsMessage) {
	if hasUnfinishedJob(cacheObjSubType[`job_shops`]) {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Shops is already running",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}

	// fan out to all active and non idle clients
	clts, err := getAllIdleClientID64()
	if err != nil || len(clts) == 0 {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Busy, please retry later.",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}

	j := JobPayloadShops{
		Status:   0,
		ChatID64: m.ChatID64,
		MsgID64:  m.ID64,
		Msgs:     make([]ChatWarsMessage, 0),
	}
	b, err := json.Marshal(j)
	logOnError(err, "botShops : Marshal")
	jobID64, err := createJob(cacheObjSubType[`job_shops`], objJobPriority, clts[0], 0, time.Unix(maxUnixTimestamp, 0).UTC(), b)

	for i, id := range clts {
		j2 := JobPayloadShopsSlave{
			JobCallbackID64: jobID64,
			Status:          0,
			Slaves:          int64(len(clts)),
			Shops:           make([]string, 0),
		}
		for j, s := range cfg.Bot.Shops {
			if (j % len(clts)) == i {
				j2.Shops = append(j2.Shops, s.Link)
			}
		}
		b, err = json.Marshal(j2)
		logOnError(err, "botShops : Marshal Slave")
		_, err = createJob(cacheObjSubType[`job_shops_slave`], objJobPriority, id, 0, time.Now().UTC(), b)
	}

	c := TGCommand{
		Type:         commandReplyMsg,
		Text:         fmt.Sprintf("Shops coming (ETA : %ds)", (len(cfg.Bot.Shops)/len(clts))*8),
		FromMsgID64:  m.ID64,
		FromChatID64: m.ChatID64,
	}
	TGCmdQueue <- c

	return
}

func botBrewItem(m *ChatWarsMessage, r *regexp.Regexp) {
	if hasUnfinishedJob(cacheObjSubType[`job_brew_item`]) {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Brew Item is already running",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}

	clt, err := getLockedIdleClient()
	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Busy, please retry later.",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()

	p := JobPayloadBrewItem{
		MsgID64:  m.ID64,
		ChatID64: m.ChatID64,
		Status:   0,
	}

	p.ObjItemID64 = getObjItemID(r.ReplaceAllString(m.Text, "${Code}"))

	fmt.Printf("Code[%s] : %d\n", r.ReplaceAllString(m.Text, "${Code}"), p.ObjItemID64)

	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err = createJob(cacheObjSubType[`job_brew_item`], objJobPriority, m.TGSenderUserID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Brew item coming",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botCraftItem(m *ChatWarsMessage, r *regexp.Regexp) {
	if hasUnfinishedJob(cacheObjSubType[`job_craft_item`]) {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Craft Item is already running",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}

	clt, err := getLockedIdleClient()
	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Busy, please retry later.",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}
	userID64 := clt.TGUserID64
	clt.Mux.Unlock()

	p := JobPayloadCraftItem{
		MsgID64:  m.ID64,
		ChatID64: m.ChatID64,
		Status:   0,
	}
	p.ObjItemID64, err = getCraftItemID(r.ReplaceAllString(m.Text, "${Cmd}"))
	logOnError(err, "botCraftItem : getCraftItemID")

	if len(r.ReplaceAllString(m.Text, "${Quantity}")) > 0 {
		p.Quantity, err = strconv.ParseInt(r.ReplaceAllString(m.Text, "${Quantity}"), 10, 64)
		logOnError(err, "botCraftItem : ParseInt")
	} else {
		p.Quantity = 1
	}

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}

	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err = createJob(cacheObjSubType[`job_craft_item`], objJobPriority, userID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Craft summary coming",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botUserConfigPillage(m *ChatWarsMessage, set bool) {
	clt, _ := getLockedClient(m.TGUserID64, false)
	clt.Config.InterceptPillage = set
	clt.Mux.Unlock()
	botUserConfig(m)
	return
}

func botUserConfigDeposit(m *ChatWarsMessage, set bool) {
	clt, _ := getLockedClient(m.TGUserID64, false)
	clt.Config.AutoDeposit = set
	clt.Mux.Unlock()
	botUserConfig(m)
	return
}

func botUserConfigWartime(m *ChatWarsMessage, set string) {
	clt, _ := getLockedClient(m.TGUserID64, false)
	clt.Config.Wartime = set
	clt.Mux.Unlock()
	botUserConfig(m)
	return
}

func botUserConfig(m *ChatWarsMessage) {
	clt, _ := getLockedClient(m.TGUserID64, false)
	clt.Mux.Unlock()
	out := fmt.Sprintf("Config for %s (running build %s):\n", clt.Login, clt.Build)
	if clt.Config.InterceptPillage {
		out = fmt.Sprintf("%s  Pillage : ON (<a href=\"https://t.me/share/url?url=/config_pillage_off\">set off</a>)\n", out)
	} else {
		out = fmt.Sprintf("%s  Pillage : OFF (<a href=\"https://t.me/share/url?url=/config_pillage_on\">set on</a>)\n", out)
	}
	if clt.Config.Wartime == `🛡Defend` {
		out = fmt.Sprintf("%s  Wartime : DEFEND CASTLE (<a href=\"https://t.me/share/url?url=/config_def_guild\">set to guild</a>)\n", out)
	} else {
		out = fmt.Sprintf("%s  Wartime : DEFEND GUILD (<a href=\"https://t.me/share/url?url=/config_def_castle\">set to castle</a>)\n", out)
	}

	if clt.Config.AutoDeposit {
		out = fmt.Sprintf("%s  Deposit : ON (<a href=\"https://t.me/share/url?url=/config_deposit_off\">set off</a>)\n", out)
		if len(clt.Config.AutoDepositItems) == 0 {
			out = fmt.Sprintf("%s    <a href=\"https://t.me/share/url?url=/config_dep_add_item\">Add individual items</a>\n", out)
		} else {
			out = fmt.Sprintf("%s  Individual items\n", out)
			for _, v := range clt.Config.AutoDepositItems {
				o, err := getObjItem(getObjItemID(v, ``))
				logOnError(err, "botUserConfig : getObjItem("+v+")")
				out = fmt.Sprintf("%s    %s (<a href=\"https://t.me/share/url?url=/config_dep_del_item %s\">remove</a>)\n", out, o.Names[0], o.Code)
			}
		}
		if len(clt.Config.AutoDepositTypes) == 0 {
			out = fmt.Sprintf("%s    <a href=\"https://t.me/share/url?url=/config_dep_add_type\">Add item types</a>\n", out)
		} else {
			out = fmt.Sprintf("%s  Item types\n", out)
			for _, v := range clt.Config.AutoDepositTypes {
				out = fmt.Sprintf("%s    %s (<a href=\"https://t.me/share/url?url=/config_dep_del_type %s\">remove</a>)\n", out, v, v)
			}
		}
	} else {
		out = fmt.Sprintf("%s  Deposit : OFF (<a href=\"https://t.me/share/url?url=/config_deposit_on\">set on</a>)\n", out)
	}
	c := TGCommand{
		Type:         commandReplyMsg,
		Text:         out,
		FromMsgID64:  m.ID64,
		FromChatID64: m.ChatID64,
		ParseMode:    cmdParseModeHTML,
	}
	TGCmdQueue <- c
	return
}

func botRefreshMsg(m *ChatWarsMessage, r *regexp.Regexp) {

	p := JobPayloadMsgRefresh{}

	p.ObjID64, _ = strconv.ParseInt(r.ReplaceAllString(m.Text, "${MsgID}"), 10, 64)

	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err := createJob(cacheObjSubType[`job_msg_refresh`], objJobPriority, m.TGSenderUserID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Refresh scheduled",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botVaultVal(m *ChatWarsMessage) {
	p := JobPayloadVaultVal{
		MsgID64:  m.ID64,
		ChatID64: m.ChatID64,
		Status:   0,
	}

	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err := createJob(cacheObjSubType[`job_vault_val`], objJobPriority, m.TGSenderUserID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Vault val coming",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botVaultValOth(m *ChatWarsMessage) {
	p := JobPayloadVaultValOth{
		MsgID64:  m.ID64,
		ChatID64: m.ChatID64,
		Status:   0,
	}

	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err := createJob(cacheObjSubType[`job_vault_val_oth`], objJobPriority, m.TGSenderUserID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Vault val (other) coming",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botAlchAll(m *ChatWarsMessage) {

	p := JobPayloadAlchAll{
		MsgID64:  m.ID64,
		ChatID64: m.ChatID64,
		Status:   0,
		ManaNow:  0,
		ManaMax:  0,
	}

	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err := createJob(cacheObjSubType[`job_alch_all`], objJobPriority, m.TGSenderUserID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Alch all coming",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botCraftAll(m *ChatWarsMessage, r *regexp.Regexp) {
	if hasUnfinishedJob(cacheObjSubType[`job_craft_all`]) {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Craft All is already running",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}

	clt, err := getLockedIdleClient()
	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Busy, please retry later.",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}
	userID64 := clt.TGUserID64
	clt.Mux.Unlock()

	p := JobPayloadCraftAll{
		MsgID64:  m.ID64,
		ChatID64: m.ChatID64,
		Status:   0,
	}

	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err = createJob(cacheObjSubType[`job_craft_all`], objJobPriority, userID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Craft all coming",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botGetStash(m *ChatWarsMessage, r *regexp.Regexp) {
	var (
		userID64      int64 = 0
		userBusyUntil time.Time
	)

	if hasUnfinishedJob(cacheObjSubType[`job_get_stash`]) {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Get Stash is already running",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}

	p := JobPayloadGetStash{
		MsgID64:     m.ID64,
		ChatID64:    m.ChatID64,
		ClientCount: 0,
		Stash:       make(map[int64]int64),
	}

	busy := time.Now().UTC()
	muxClients.RLock()
	for _, c := range clients {
		if c.Active {
			p.ClientCount++
			p.ClientID64 = append(p.ClientID64, c.TGUserID64)
			if userID64 == 0 {
				userID64 = c.TGUserID64
				userBusyUntil = c.CWBusyUntil
			} else if userBusyUntil.After(c.CWBusyUntil) {
				userID64 = c.TGUserID64
				userBusyUntil = c.CWBusyUntil
			}

			if c.CWBusyUntil.After(busy) {
				busy = c.CWBusyUntil
			}
		}
	}
	muxClients.RUnlock()

	if p.ClientCount == 0 {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "No clients online.",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
		return
	}
	b, _ := json.Marshal(p)
	t := time.Now().UTC().Add(1 * time.Second)
	_, err := createJob(cacheObjSubType[`job_get_stash`], objJobPriority, userID64, 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else if busy.After(time.Now().UTC()) {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("Clients busy, delayed for %v.", busy.Sub(time.Now().UTC())),
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Stash coming.",
			FromMsgID64:  m.ID64,
			FromChatID64: m.ChatID64,
		}
		TGCmdQueue <- c
	}

	return
}

func botSaveRes(m *tb.Message) {
	if !m.Private() {
		return
	}

	c := TGCommand{
		Type:         commandReplyMsg,
		Text:         "Not coded yet.",
		FromMsgID64:  int64(m.ID),
		FromChatID64: m.Chat.ID,
	}
	TGCmdQueue <- c
}

func botVaultHelp(m *tb.Message) {
	if !(m.Private() || m.Chat.ID == cfg.Bot.Mainchat) {
		return
	}

	c := TGCommand{
		Type: commandReplyMsg,
		Text: `
	/vault_all <user> - All items
	/vault_res <user> - Resources
	/vault_alch <user> - Alchemy
	/vault_misc <user> - Miscellaneous
	/vault_rec <user> - Recipes
	/vault_part <user> - Parts
	/vault_other <user> - Other
	/vault_item <code>... - Specific items`,
		FromMsgID64:  int64(m.ID),
		FromChatID64: m.Chat.ID,
	}
	TGCmdQueue <- c
}

func botVaultAll(m *tb.Message) {
	l := []int64{cacheObjSubType[`item_res`], cacheObjSubType[`item_alch`], cacheObjSubType[`item_misc`], cacheObjSubType[`item_recipe`], cacheObjSubType[`item_part`], cacheObjSubType[`item_other`]}
	botVault(m, l)
}

func botVaultRes(m *tb.Message) {
	l := []int64{cacheObjSubType[`item_res`]}
	botVault(m, l)
}

func botVaultAlch(m *tb.Message) {
	l := []int64{cacheObjSubType[`item_alch`]}
	botVault(m, l)
}

func botVaultMisc(m *tb.Message) {
	l := []int64{cacheObjSubType[`item_misc`]}
	botVault(m, l)
}

func botVaultRec(m *tb.Message) {
	l := []int64{cacheObjSubType[`item_recipe`]}
	botVault(m, l)
}

func botVaultPart(m *tb.Message) {
	l := []int64{cacheObjSubType[`item_part`]}
	botVault(m, l)
}

func botVaultOther(m *tb.Message) {
	l := []int64{cacheObjSubType[`item_other`]}
	botVault(m, l)
}

func botVaultItem(m *tb.Message) {
	if !(m.Private() || m.Chat.ID == cfg.Bot.Mainchat) {
		return
	}

	p := JobPayloadVaultItemStatus{
		ItemListID64:    nil,
		DepositChatID64: cfg.Bot.Depositchat,
		UserID64:        int64(m.Sender.ID),
	}

	r := regexp.MustCompile("([a-z][0-9]{2}[a-e]{0,1}|([0-9]{2}))")
	for _, l := range r.FindAllStringSubmatch(m.Payload, -1) {
		item := getObjItemID(l[1], ``)
		if item != 0 {
			p.ItemListID64 = append(p.ItemListID64, item)
		}
	}

	if len(p.ItemListID64) > 0 {
		b, _ := json.Marshal(p)
		t := time.Now().UTC()
		_, err := createJob(cacheObjSubType[`job_vault_item_status`], objJobPriority, int64(m.Sender.ID), 0, t, b)
		if err != nil {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         fmt.Sprintf("%s", err),
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
		}

	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         `/vault_item <code> ...`,
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}

	return

}

func botVault(m *tb.Message, itemTypeList []int64) {
	/*
		b, _ := json.Marshal(m)
		log.Printf("botVault (msg) :\n%s\n", string(b))
		for _, e := range m.Entities {
			if e.Type == tb.EntityMention {
				log.Printf("botVault (user) : %s\n", m.Text[e.Offset:e.Offset+e.Length])
			}
		}
	*/
	if !(m.Private() || m.Chat.ID == cfg.Bot.Mainchat) {
		return
	}

	p := JobPayloadVaultUserStatus{
		UserID64:         int64(m.Sender.ID),
		UserListID64:     nil,
		ItemTypeListID64: nil,
		DepositChatID64:  cfg.Bot.Depositchat,
	}
	p.UserListID64 = append(p.UserListID64, int64(m.Sender.ID))
	p.ItemTypeListID64 = append(p.ItemTypeListID64, itemTypeList...)

	b, _ := json.Marshal(p)
	t := time.Now().UTC()
	_, err := createJob(cacheObjSubType[`job_vault_user_status`], objJobPriority, int64(m.Sender.ID), 0, t, b)

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}
	return
}

func botGDepositAll(m *tb.Message) {
	if !m.Private() {
		return
	}

	p := JobPayloadGDeposit{
		MsgID64:    int64(m.ID),
		ChatID64:   m.Chat.ID,
		ResObjID64: nil,
		Status:     0,
	}

	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`01`, `Thread`))
	if m.Sender.ID != 480149577 {
		p.ResObjID64 = append(p.ResObjID64, getObjItemID(`02`, `Stick`))
	}
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`03`, `Pelt`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`04`, `Bone`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`05`, `Coal`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`07`, `Powder`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`08`, `Iron Ore`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`09`, `Cloth`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`10`, `Silver Ore`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`11`, `Bauxite`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`13`, `Magic Stone`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`14`, `Wooden Shaft`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`15`, `Sapphire`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`17`, `Ruby`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`18`, `Hardener`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`19`, `Steel`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`21`, `Bone Powder`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`22`, `String`))
	if m.Sender.ID != 480149577 {
		p.ResObjID64 = append(p.ResObjID64, getObjItemID(`23`, `Coke`))
	}
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`24`, `Purified Powder`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`28`, `Silver mold`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`31`, `Rope`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`33`, `Metal Plate`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`34`, `Metallic Fiber`))
	p.ResObjID64 = append(p.ResObjID64, getObjItemID(`35`, `Crafted Leather`))

	list := getSQLListID64(fmt.Sprintf("select o.id from obj o where o.obj_sub_type_id = %d;", cacheObjSubType[`item_recipe`]))
	p.ResObjID64 = append(p.ResObjID64, list...)

	list = getSQLListID64(fmt.Sprintf("select o.id from obj o where o.obj_sub_type_id = %d;", cacheObjSubType[`item_part`]))
	p.ResObjID64 = append(p.ResObjID64, list...)

	/*
		p.ResObjID64 = append(p.ResObjID64, getObjItemID(`39`, `Stinky Sumac`))
		p.ResObjID64 = append(p.ResObjID64, getObjItemID(`s01`, `📕Scroll of Rage`))
		p.ResObjID64 = append(p.ResObjID64, getObjItemID(`w07`, `Rapier`))
	*/

	b, _ := json.Marshal(p)
	t := time.Now().UTC()
	_, err := createJob(cacheObjSubType[`job_gdeposit`], objJobPriority, int64(m.Chat.ID), 0, t, b)

	//log.Printf("botGDepositAll : json : %s\n", string(b))

	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         fmt.Sprintf("%s", err),
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Deposit started",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}

	return
}

func botGWithdraw(m *tb.Message) {
	if !m.Private() {
		return
	}

	clt, err := getLockedIdleClient()
	if err != nil {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Busy, please retry later.",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	userID64 := clt.TGUserID64
	clt.Mux.Unlock()

	r := regexp.MustCompile("^(( )*[a-z0-9]+ [0-9]+( )*)+$")
	if r.MatchString(m.Payload) {
		rx := regexp.MustCompile("(?P<Item>[a-z0-9]+) (?P<Quantity>[0-9]+)")
		p := JobPayloadGWithdraw{
			MsgID64:   int64(m.ID),
			ChatID64:  m.Chat.ID,
			UserID64:  int64(m.Sender.ID),
			Status:    0,
			Validated: false,
		}
		items := []JobPayloadGWithdrawItem{}
		for _, l := range rx.FindAllStringSubmatch(m.Payload, -1) {
			log.Printf("botGWithdraw : %s / %s / %s\n", l[0], l[1], l[2])
			i := l[1]
			q, _ := strconv.ParseInt(l[2], 10, 64)
			item := JobPayloadGWithdrawItem{
				Code:     i,
				Required: q,
			}
			items = append(items, item)
		}
		p.Items = items

		b, _ := json.Marshal(p)
		t := time.Now().UTC()
		_, err := createJob(cacheObjSubType[`job_gwithdraw`], objJobPriority, userID64, 0, t, b)
		//_, err := createJob(cacheObjSubType[`job_gwithdraw`], objJobPriority, cfg.Bot.Admin, 0, t, b)
		if err != nil {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         fmt.Sprintf("%s", err),
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
		} else {
			log.Printf("botGWithdraw : %s\n", string(b))
		}

	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Wrong format",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}

	return
}

func botTimer(m *tb.Message) {
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()

	r := regexp.MustCompile("^(?P<Duration>([0-9]*(s|m|h))+) \"(?P<Msg>(.*))\"$")
	if r.MatchString(m.Payload) {
		d, err := time.ParseDuration(r.ReplaceAllString(m.Payload, "${Duration}"))
		if err != nil {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         fmt.Sprintf("%s", err),
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
		} else {
			p := JobPayloadMsgClient{
				Text:     r.ReplaceAllString(m.Payload, "${Msg}"),
				MsgID64:  int64(m.ID),
				ChatID64: m.Chat.ID,
			}
			b, _ := json.Marshal(p)
			t := time.Now().UTC().Add(d)
			objID64, err := createJob(cacheObjSubType[`job_msg_client`], objJobPriority, int64(m.Chat.ID), 0, t, b)
			logOnError(err, "botTimer : createJob")
			if err != nil {
				c := TGCommand{
					Type:         commandReplyMsg,
					Text:         fmt.Sprintf("%s", err),
					FromMsgID64:  int64(m.ID),
					FromChatID64: m.Chat.ID,
				}
				TGCmdQueue <- c
			} else {
				c := TGCommand{
					Type:         commandReplyMsg,
					Text:         fmt.Sprintf("Job #%d scheduled at %s", objID64, t.Format(time.RFC850)),
					FromMsgID64:  int64(m.ID),
					FromChatID64: m.Chat.ID,
				}
				TGCmdQueue <- c
			}
		}

	}

	r = regexp.MustCompile("^(?P<User>([0-9]+)) (?P<Duration>([0-9]*(s|m|h))+) \"(?P<Msg>(.*))\"$")
	if r.MatchString(m.Payload) {
		if clt.TGUserID64 != cfg.Bot.Admin {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         "Admin only",
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
			return
		}
		d, err := time.ParseDuration(r.ReplaceAllString(m.Payload, "${Duration}"))
		if err != nil {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         fmt.Sprintf("%s", err),
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
		} else {
			userID, _ := strconv.ParseInt(r.ReplaceAllString(m.Text, "${User}"), 10, 64)
			p := JobPayloadMsgClient{
				Text:     r.ReplaceAllString(m.Payload, "${Msg}"),
				MsgID64:  int64(m.ID),
				ChatID64: m.Chat.ID,
			}
			b, _ := json.Marshal(p)
			t := time.Now().UTC().Add(d)
			objID64, err := createJob(cacheObjSubType[`job_msg_client`], objJobPriority, userID, 0, t, b)
			logOnError(err, "botTimer : createJob")
			if err != nil {
				c := TGCommand{
					Type:         commandReplyMsg,
					Text:         fmt.Sprintf("%s", err),
					FromMsgID64:  int64(m.ID),
					FromChatID64: m.Chat.ID,
				}
				TGCmdQueue <- c
			} else {
				c := TGCommand{
					Type:         commandReplyMsg,
					Text:         fmt.Sprintf("Job #%d scheduled at %s", objID64, t.Format(time.RFC850)),
					FromMsgID64:  int64(m.ID),
					FromChatID64: m.Chat.ID,
				}
				TGCmdQueue <- c
			}
		}

	}

	return
}

func botCleanupJob(m *tb.Message) {
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()

	c := TGCommand{
		Type:         commandReplyMsg,
		Text:         "Cleanup started",
		FromMsgID64:  int64(m.ID),
		FromChatID64: m.Chat.ID,
	}
	TGCmdQueue <- c

	cleanupJobData()

	return
}

func botRestartJob(m *tb.Message) {
	if !m.Private() {
		return
	}
	clt, ok := getLockedClient(m.Chat.ID, false)
	if !ok {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "Client not registered",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}
	clt.Mux.Unlock()

	if len(m.Payload) > 0 {
		jobID64, err := strconv.ParseInt(m.Payload, 10, 64)
		if err != nil {
			logOnError(err, "botRestartJob : ParseInt")
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         "error",
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
			return
		}
		err = rescheduleJob(jobID64, 0, time.Now().UTC())
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "done",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
		return
	}

	c := TGCommand{
		Type:         commandReplyMsg,
		Text:         "no Job ID",
		FromMsgID64:  int64(m.ID),
		FromChatID64: m.Chat.ID,
	}
	TGCmdQueue <- c
	return

	return
}

func botGetItemId(m *tb.Message) {
	if len(m.Payload) > 0 {
		objItemID64 := getObjItemID(``, m.Payload)
		if objItemID64 != 0 {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         fmt.Sprintf("Identified item #%d", objItemID64),
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
		} else {
			c := TGCommand{
				Type:         commandReplyMsg,
				Text:         "Can''t identify item",
				FromMsgID64:  int64(m.ID),
				FromChatID64: m.Chat.ID,
			}
			TGCmdQueue <- c
		}
	} else {
		c := TGCommand{
			Type:         commandReplyMsg,
			Text:         "No item name to identify",
			FromMsgID64:  int64(m.ID),
			FromChatID64: m.Chat.ID,
		}
		TGCmdQueue <- c
	}

	return
}

func botShutdown() {
	os.Exit(0)
}