botlike.go

package main

import (
    "database/sql"
    "flag"
    "github.com/ahmdrz/goinsta"
    "github.com/ahmdrz/goinsta/response"
    _ "github.com/lib/pq"
    "log"
    "os"
    "regexp"
    "strings"
    "sync"
    "time"
)

var (
    username string
    password string
    email    string
    sleep    int64
    add      bool
    show     bool
    remove   bool
    connStr  string = "user=postgres dbname=db_instagram sslmode=disable password=ccocot123"
)

func panicOnError(err error) {
    if err != nil {
        log.Panic(err)
    }
}

func addAccount(db *sql.DB) {
    isUsernameEmpty := !(len(username) > 0)
    isPasswordEmpty := !(len(password) > 0)
    isEmailEmpty := !(len(email) > 0)
    if isUsernameEmpty || isPasswordEmpty || isEmailEmpty {
        log.Panic("Username, Password or Email Empty\n")
    }
    insta := goinsta.New(username, password)
    log.Print("Login Instagram ...\n")
    err := insta.Login()
    defer insta.Logout()
    panicOnError(err)
    _, err = db.Exec(`INSERT INTO account_info VALUES($1, $2, $3)`, username, password, email)
    panicOnError(err)
    log.Printf("User Added ! \n")
}

func showAccount(db *sql.DB) {
    rows, err := db.Query(`SELECT username,password FROM account_info`)
    panicOnError(err)
    index := 0
    for rows.Next() {
        index++
        var usernameTmp string
        var passwordTmp string
        err := rows.Scan(&usernameTmp, &passwordTmp)
        panicOnError(err)
        log.Printf("%d. Username: %s Password: %s \n", index, usernameTmp, passwordTmp)
    }
}

func deleteAccount(db *sql.DB) {
    isUsernameEmpty := !(len(username) > 0)
    if isUsernameEmpty {
        log.Panic("Username to delete Empty\n")
    }
    _, err := db.Exec(`DELETE FROM account_info WHERE username = $1`, username)
    panicOnError(err)
    log.Printf("User Deleted !\n")
}

func init() {
    // flag
    flag.StringVar(&username, "username", "", "instagram account username")
    flag.StringVar(&password, "password", "", "instagram account password")
    flag.StringVar(&email, "email", "", "instagram account email")
    flag.Int64Var(&sleep, "sleep", 2, "sleep in minute")
    flag.BoolVar(&add, "add", false, "add account instagram")
    flag.BoolVar(&show, "show", false, "to show instagram account list")
    flag.BoolVar(&remove, "remove", false, "remove instagram account")
    flag.Parse()

    //db connection
    db, err := sql.Open("postgres", connStr)
    panicOnError(err)
    defer db.Close()

    switch {
    case add: //if flag add true
        addAccount(db)
        os.Exit(0)
    case show: // if flag show true
        showAccount(db)
        os.Exit(0)
    case remove: //if flag remove true
        deleteAccount(db)
        os.Exit(0)
    }
}

func main() {

    //db connection
    db, err := sql.Open("postgres", connStr)
    panicOnError(err)
    defer db.Close()

    // get account
    rows, err := db.Query(`SELECT username, password FROM account_info`)
    panicOnError(err)
    accounts := [][]string{}
    for rows.Next() {
        var usernameTmp string
        var passwordTmp string
        rows.Scan(&usernameTmp, &passwordTmp)
        itemToAppend := [][]string{{usernameTmp, passwordTmp}}
        accounts = append(accounts, itemToAppend...)
    }

    log.Printf("Get All Worker [Total: %d account] \n", len(accounts))
    // setup channel and waitgroup and worker login
    var wg sync.WaitGroup
    ch := make(chan *goinsta.Instagram, len(accounts))
    for _, account := range accounts {
        wg.Add(1)
        go login(&wg, account, ch)
    }
    wg.Wait()
    close(ch)
    log.Printf("All worker Logged In, close channel and start to Work !!!\n")

    //getTimeLine
    for account := range ch {
        wg.Add(1)
        go getTimeLine(&wg, account, db)
    }

    wg.Wait()
    log.Printf("All done")
}

func login(wg *sync.WaitGroup, account []string, ch chan *goinsta.Instagram) {
    defer wg.Done()
    log.Printf("worker %s try Login ... \n", account[0])
    insta := goinsta.New(account[0], account[1])
    err := insta.Login()
    panicOnError(err)
    log.Printf("worker %s Login Success ... \n", account[0])
    ch <- insta
}

func getTimeLine(wg *sync.WaitGroup, account *goinsta.Instagram, db *sql.DB) {
    defer wg.Done()
    accountInfo, err := account.GetProfileData()
    worker := accountInfo.User.Username
    panicOnError(err)
    maxID := ""
    for {
        feed, err := account.Timeline(maxID)
        feed.AutoLoadMore = true
        panicOnError(err)
        for index, item := range feed.Items {
            if mod := index % 3; index > 0 && mod == 0 {
                time.Sleep(time.Duration(sleep) * time.Minute)
            }
            re := regexp.MustCompile(`(\#[a-zA-Z]+\b)`)
            match := re.FindAllString(item.Caption.Text, -1)
            result := doLike(account, &item, worker)
            _, err := db.Exec(`INSERT INTO event VALUES(NOW(), $1, $2, $3, $4, $5);`,
                worker,
                result,
                strings.Join(match, " "),
                item.User.Username,
                item.ID)
            panicOnError(err)
        }
        if feed.MoreAvailable {
            maxID = feed.NextMaxID
        } else {
            break
        }
    }
}

func doLike(insta *goinsta.Instagram, item *response.MediaItemResponse, worker string) bool {
    liked := true
    if !item.HasLiked {
        _, err := insta.Like(item.ID)
        if err != nil {
            liked = false
        }
    }

    log.Printf("[%s] %s => %s [%t]", worker, item.User.Username, item.ID, liked)
    return liked
}