func fetchChannelHistory(api *slack.Client, ID string) []slack.Message {
historyParams := slack.NewHistoryParameters()
historyParams.Count = 1000
// Fetch History
history, err := api.GetChannelHistory(ID, historyParams)
check(err)
messages := history.Messages
latest := messages[len(messages)-1].Timestamp
for {
if history.HasMore != true {
break
}
historyParams.Latest = latest
history, err = api.GetChannelHistory(ID, historyParams)
check(err)
length := len(history.Messages)
if length > 0 {
latest = history.Messages[length-1].Timestamp
messages = append(messages, history.Messages...)
}
}
return messages
}
func addChannelHistory(s *slack.Slack, db *sql.DB, channel, oldest string) (string, error) {
params := slack.NewHistoryParameters()
params.Oldest = oldest
params.Count = 1000
history, err := s.GetChannelHistory(channel, params)
if err != nil {
return "", err
}
for _, msg := range history.Messages {
if msg.SubType != "" {
continue
}
fmt.Printf("%s: %s\n", msg.User, msg.Text)
ts := timestampToTime(msg.Timestamp)
_, err := db.Exec(
`INSERT INTO messages(channel_id, user_id, text, timestamp, created_at, updated_at)
VALUES(?, ?, ?, ?, NOW(), NOW())
`,
channel, msg.User, msg.Text, ts.Format("2006-01-02 15:04:05"))
if err != nil {
return "", err
}
}
if len(history.Messages) > 0 {
return history.Messages[0].Timestamp, nil
}
return "", nil
}
func (a arriba) retrieveChannelStandup(c conversation) (channelStandup, error) {
params := slack.NewHistoryParameters()
params.Count = 1000
now := time.Now().UTC()
params.Latest = fmt.Sprintf("%d", now.Unix())
params.Oldest = fmt.Sprintf("%d", now.AddDate(0, 0, -a.historyDaysLimit).Unix())
// It would be way more efficient to use slack.SearchMsgs instead
// of traversing the whole history, but that's not allowed for bots :(
cstandup := make(channelStandup)
for {
logrus.Debugf(
"Requesting history for conversation %s with parameters %#v",
c.getID(),
params)
history, error := c.getHistory(a.rtm, params)
if error != nil || history == nil || len(history.Messages) == 0 {
return cstandup, error
}
logrus.Debugf(
"Got history chunk (from %s to %s, latest %s) for conversation %s",
history.Messages[len(history.Messages)-1].Msg.Timestamp,
history.Messages[0].Msg.Timestamp, history.Latest, c.getID())
for _, msg := range history.Messages {
if _, ok := cstandup[msg.User]; ok {
// we already have the latest standup message for this user
continue
}
standupMsg, ok := a.extractChannelStandupMsg(msg.Msg)
if ok && standupMsg.text != "" {
cstandup[msg.User] = standupMsg
}
}
if !history.HasMore {
break
}
latestMsg := history.Messages[len(history.Messages)-1]
params.Latest = latestMsg.Timestamp
params.Inclusive = false
}
return cstandup, nil
}
func (a arriba) retrieveChannelStandup(c conversation) (channelStandup, error) {
params := slack.NewHistoryParameters()
params.Count = 1000
params.Oldest = fmt.Sprintf(
"%d",
time.Now().UTC().AddDate(-a.historyDaysLimit, 0, 0).Unix(),
)
// It would be way more efficient to use slack.SearchMsgs instead
// of traversing the whole history, but that's not allowed for bots :(
cstandup := make(channelStandup)
for {
history, error := c.getHistory(a.rtm, params)
if error != nil {
return cstandup, error
}
for _, msg := range history.Messages {
if _, ok := cstandup[msg.User]; ok {
// we already have the latest standup message for this user
continue
}
standupMsg, ok := a.extractChannelStandupMsg(msg.Msg)
if ok && standupMsg.text != "" {
cstandup[msg.User] = standupMsg
}
}
if !history.HasMore {
break
}
oldestMsg := history.Messages[len(history.Messages)-1]
params.Oldest = oldestMsg.Timestamp
params.Inclusive = false
}
return cstandup, nil
}
func cleanHistory(channelID string, api *slack.Client, msgQueue *utility.Queue, histSize int, histCond *sync.Cond, threadWait *sync.WaitGroup) {
defer threadWait.Done()
defer histCond.Signal()
histCond.L.Lock()
defer histCond.L.Unlock()
logging.Log.Infof("(%s) Starting cleanHistory", channelID)
histParams := slack.NewHistoryParameters()
histParams.Inclusive = true
histCountMax := 1000
// build history with histSize messages
logging.Log.Infof("(%s) Building history with %v messages", channelID, histSize)
var history *slack.History
var histErr error
nRemaining := histSize
for nRemaining > 0 {
if nRemaining > histCountMax {
histParams.Count = histCountMax
} else {
histParams.Count = nRemaining
}
history, histErr = api.GetChannelHistory(channelID, histParams)
if histErr != nil {
logging.Log.Errorf("(%s) Unable to get the channel history: %v", channelID, histErr)
return
}
iLastMsg := len(history.Messages) - 1
//logging.Log.Debug("0: %v, %v: %v", history.Messages[0].Timestamp, iLastMsg, history.Messages[iLastMsg].Timestamp)
logging.Log.Debugf("(%s) In skip loop; obtained history with %v messages", channelID, len(history.Messages))
for iMsg := iLastMsg; iMsg >= 0; iMsg-- {
msgQueue.Push(history.Messages[iMsg].Timestamp)
//logging.Log.Debugf("(%s) Pushing to queue: %s", channelID, history.Messages[iMsg].Timestamp)
}
if !history.HasMore {
return
}
histParams.Latest = history.Messages[iLastMsg].Timestamp
histParams.Inclusive = false
nRemaining -= histCountMax
}
histParams.Count = histCountMax
nDeleted := 0
for history.HasMore == true {
history, histErr = api.GetChannelHistory(channelID, histParams)
if histErr != nil {
logging.Log.Errorf("(%s) Unable to get the channel history: %v", channelID, histErr)
return
}
logging.Log.Debugf("(%s) Deleting %v items (latest: %v)", channelID, len(history.Messages), history.Latest)
for _ /*iMsg*/, message := range history.Messages {
//logging.Log.Debugf("(%s) Deleting: %s", channelID, message.Timestamp)
_, _ /*respChan, respTS,*/, respErr := api.DeleteMessage(channelID, message.Timestamp)
if respErr != nil {
logging.Log.Warningf("(%s) Unable to delete message: %v", channelID, respErr)
}
//logging.Log.Debugf("(%s) Deletion response: %s, %s, %v", channelID, respChan, respTS, respErr)
nDeleted++
}
histParams.Latest = history.Messages[len(history.Messages)-1].Timestamp
}
logging.Log.Noticef("(%s) Deleted %v messages", channelID, nDeleted)
return
}
func main() {
slack_token := os.Getenv("SLACK_TOKEN")
slack_group := os.Getenv("SLACK_GROUP")
card_no := os.Getenv("CARD_NO")
if slack_token == "" || slack_group == "" || card_no == "" {
log.Fatal("SLACK_TOKEN=xxxx-1111111111-1111111111-11111111111-111111 SLACK_GROUP=GXXXXXXXX CARD_NO=1111222233334444 ./go-ubot-oddday-checker (version: " + version.Version + ")")
}
res, err := goreq.Request{Uri: UBOT_ODDDAY_URL}.Do()
if err != nil {
log.Fatal(err)
}
doc, err := goquery.NewDocumentFromReader(res.Body)
if err != nil {
log.Fatal(err)
}
tbCode, found := doc.Find("#tbCode").Attr("value")
if !found {
log.Error("Cannot find tbCode.")
return
}
viewstate, found := doc.Find("#__VIEWSTATE").Attr("value")
if !found {
log.Error("Cannot find viewstate.")
return
}
eventvalidation, found := doc.Find("#__EVENTVALIDATION").Attr("value")
if !found {
log.Error("Cannot find eventvalidation.")
return
}
form := url.Values{}
form.Add("__EVENTTARGET", "")
form.Add("__EVENTARGUMENT", "")
form.Add("__VIEWSTATE", viewstate)
form.Add("tbCode", tbCode)
form.Add("__CALLBACKID", "__Page")
form.Add("__CALLBACKPARAM", "QRY%%"+card_no+"%%"+tbCode+"%%"+tbCode+"%%")
form.Add("__EVENTVALIDATION", eventvalidation)
res, err = goreq.Request{
Method: "POST",
Uri: UBOT_ODDDAY_URL,
UserAgent: "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:43.0) Gecko/20100101 Firefox/43.0",
ContentType: "application/x-www-form-urlencoded",
Body: form.Encode(),
}.WithHeader("Referer", UBOT_ODDDAY_URL).Do()
if err != nil {
log.Fatal(err)
}
body, _ := res.Body.ToString()
// Parse the HTML into nodes
rp := regexp.MustCompile(`LOGINOK@@[^@]+@@([^@]+)@@[^@]+`)
m := rp.FindStringSubmatch(body)
if m == nil {
log.Fatalf("Cannot find expected response: %s", body)
}
log.Debugf("Response: %s", m[1])
doc, err = goquery.NewDocumentFromReader(strings.NewReader(m[1]))
if err != nil {
log.Fatal(err)
}
api := slack.New(slack_token)
mParams := slack.PostMessageParameters{}
attachment := slack.Attachment{}
doc.Find("tr").Each(func(i int, s *goquery.Selection) {
sel := s.Find("td")
month := strings.TrimSpace(sel.Nodes[0].FirstChild.Data)
count := strings.TrimSpace(sel.Nodes[1].FirstChild.Data)
money := strings.TrimSpace(sel.Nodes[2].FirstChild.Data)
log.Debugf("%s,%s,%s", month, count, money)
field := slack.AttachmentField{
Title: month,
Value: count + " (" + money + ")",
}
attachment.Fields = append(attachment.Fields, field)
})
// Query all logs in past 1 month
hParams := slack.NewHistoryParameters()
hParams.Oldest = fmt.Sprint(time.Now().AddDate(0, -1, 0).Unix())
history, err := api.GetGroupHistory(slack_group, hParams)
if err != nil {
log.Fatal(err)
}
for _, msg := range history.Messages {
if msg.Text == TITLE {
for _, _attachement := range msg.Attachments {
// Compare attachment
if reflect.DeepEqual(_attachement, attachment) {
log.Debug("Found exist in slack. Skip.")
return
}
}
}
}
// Notify new message
mParams.Attachments = []slack.Attachment{attachment}
_, _, err = api.PostMessage(slack_group, TITLE, mParams)
if err != nil {
log.Fatal(err)
}
}