func PublishTweet(article *Article, replyToId string, api *anaconda.TwitterApi) (string, error) {
msg := twitterize(article)
_, err := api.PostTweet(msg, url.Values{
"in_reply_to_status_id": []string{replyToId},
})
return msg, err
}
func postImageTweet(api *anaconda.TwitterApi, gifFile string, t *anaconda.Tweet) error {
// Post
data, err := ioutil.ReadFile(gifFile)
if err != nil {
return err
}
mediaResponse, err := api.UploadMedia(base64.StdEncoding.EncodeToString(data))
if err != nil {
return err
}
v := url.Values{}
v.Set("media_ids", strconv.FormatInt(mediaResponse.MediaID, 10))
v.Set("in_reply_to_status_id", t.IdStr)
tweetString := fmt.Sprintf("@%s here are your fireworks", t.User.ScreenName)
_, err = api.PostTweet(tweetString, v)
if err != nil {
return err
} else {
// fmt.Println(result)
}
return nil
}
func updateStatus(subject string, api anaconda.TwitterApi) bool {
_, err := api.PostTweet(subject, nil)
if err != nil {
fmt.Println("Posting Tweet failed! Error : ", err)
os.Exit(1)
}
return true
}
func Tweet(status string) (tweet anaconda.Tweet, err error) {
var client *anaconda.TwitterApi
if twitterClient != nil {
client = twitterClient
} else {
client = TwitterClient()
}
return client.PostTweet(status, url.Values{})
}
func PostTweets(api *anaconda.TwitterApi, bts []BeetTweet, db *sql.DB) {
for _, bt := range bts {
//TODO: Psuedo random reminder messages. For fun, and not angering the twitter api.
_, err := api.PostTweet(fmt.Sprintf("@%s The number is %d.", bt.Name, bt.Hours), nil)
if err == nil {
query := fmt.Sprintf("UPDATE tweet SET NOTIFIED = true WHERE ID = %d;", bt.Id)
db.Query(query)
}
}
}
// Given config and observation, tweets latest update
func tweetCurrent(config Config, o string) {
fmt.Println("Preparing to tweet observation...")
var api *anaconda.TwitterApi
api = anaconda.NewTwitterApi(config.Token, config.TokenSecret)
anaconda.SetConsumerKey(config.ConsumerKey)
anaconda.SetConsumerSecret(config.ConsumerSecret)
tweet, err := api.PostTweet(o, nil)
if err != nil {
fmt.Println("update error:", err)
} else {
fmt.Println("Tweet posted:")
fmt.Println(tweet.Text)
}
}
func feedJBBS2Twitter(board *jbbsreader.Board, api *anaconda.TwitterApi) error {
done := make(chan struct{})
defer close(done)
respc, errc := board.FeedNewResponses(done)
for resp := range respc {
log.Printf("Fetched %#v\n", resp)
tweet, err := api.PostTweet(resp.Content, nil)
if err != nil {
return err
}
log.Printf("Sent tweet %#v\n", tweet)
}
return <-errc
}
// Respond to an image somebody posted
func Respond(tweet anaconda.Tweet, classification string, twitter anaconda.TwitterApi) bool {
msg := fmt.Sprintf(
"%s https://twitter.com/%s/status/%s",
message(classification),
tweet.User.IdStr,
tweet.IdStr,
)
reply, errRpl := twitter.PostTweet(msg, url.Values{})
if errRpl != nil {
log.Printf("Error responding: ", errRpl)
return false
}
// else
log.Printf("Tweeted; link: https://twitter.com/%s/status/%d\n", reply.User.ScreenName, reply.Id)
return true
}
//ツイート関数。無駄に並列化している。140字以上の分割ツイートにも対応。
func tweet(api *anaconda.TwitterApi, waitGroup *sync.WaitGroup, begin string, end string, str string) {
sLen := 140 - utf8.RuneCountInString(begin) - utf8.RuneCountInString(end)
for str != "" {
limit := int(math.Min(float64(sLen), float64(utf8.RuneCountInString(str))))
waitGroup.Add(1)
go func(api *anaconda.TwitterApi, waitGroup *sync.WaitGroup, begin, end, str string) {
defer waitGroup.Done()
tweetstr := begin + str + end
if *r {
tweetstr = reverse(tweetstr)
}
if *h {
hash := sha256.Sum256([]byte(tweetstr))
tweetstr = hex.EncodeToString(hash[:])
}
api.PostTweet(tweetstr, nil)
}(api, waitGroup, begin, end, string([]rune(str)[:limit]))
str = string([]rune(str)[limit:])
}
}
func PostTweet(api *anaconda.TwitterApi, reader io.ReadCloser) error {
buff := bytes.Buffer{}
encoder := base64.NewEncoder(base64.StdEncoding, &buff)
_, err := io.Copy(encoder, reader)
if err != nil {
return err
}
reader.Close()
encoder.Close()
media, err := api.UploadMedia(buff.String())
if err != nil {
return err
}
values := url.Values{}
values.Set("media_ids", fmt.Sprintf("%d", media.MediaID))
_, err = api.PostTweet("", values)
if err != nil {
fmt.Println(err)
}
return nil
}
func gameGenerator(api *anaconda.TwitterApi) func(anaconda.Tweet) bool {
var enemyHp int = 3 //HP is Hit Point
var myHp int = 3
var enemyTp int = 0 //Tp is Tame Point
var myTp int = 0
var turn int = 0
var maouRoutine = [3][10]int{
{0, 1, 0, 2, 0, 0, 0, 2, 0, 1}, //攻撃60%防御20%タメ20%
{1, 1, 1, 0, 0, 2, 2, 1, 1, 1}, //攻撃20%防御60%タメ20%
{0, 1, 1, 0, 2, 0, 1, 1, 1, 0}, //攻撃40%防御50%タメ10%
}
var commands = [4]string{"こうげき", "ぼうぎょ", "ため", "ひっさつ"}
var lossRep = " あなたの負けです"
var winRep = " あなたの勝ちです"
//げーむるーちん
return func(tweet anaconda.Tweet) bool {
//fmt.Println("tw",tweet.Text)
//fmt.Println("turn",)
var act = -1
for i := 0; i < len(commands); i++ {
if strings.Contains(tweet.Text, commands[i]) {
act = i
break
}
}
if act < 0 {
return false
}
turn++
turn %= len(maouRoutine)
rand.Seed(time.Now().UnixNano())
routine := rand.Intn(10)
mact := maouRoutine[turn][routine]
if enemyTp == 3 {
mact = 3
}
sendmess := "@" + tweet.User.ScreenName + " "
sendmess += "勇者は" + commands[act] + "をした\n"
sendmess += "魔王は" + commands[mact] + "をした\n"
//以下、初心者あともすふぇあ満載のif祭り
//こうげき
if mact == 0 && act != 1 {
sendmess += "勇者はダメージを受けた\n"
myHp--
}
if mact != 1 && act == 0 {
sendmess += "魔王はダメージを受けた\n"
enemyHp--
}
//ため
if act == 2 {
myTp++
sendmess += "勇者タメ" + strconv.Itoa(myTp) + "\n"
}
if mact == 2 {
enemyTp++
sendmess += "魔王タメ" + strconv.Itoa(enemyTp) + "\n"
}
//ひっさつ
if mact == 3 {
sendmess += "勇者は必殺を受けた\n"
if act == 1 {
myHp++
}
myHp -= 3
enemyTp = 0
}
if act == 3 {
if myTp < 3 {
sendmess += "勇者はためが足りなかった\n"
} else {
sendmess += "魔王は必殺を受けた\n"
if mact == 1 {
enemyHp++
}
enemyHp -= 3
}
myTp = 0
}
if enemyHp <= 0 {
sendmess += winRep
} else if myHp <= 0 {
sendmess += lossRep
}
api.PostTweet(sendmess+"【"+tweet.IdStr+"】"+tag, nil)
return enemyHp <= 0 || myHp <= 0
}
}
func onTweet(api *anaconda.TwitterApi, tw anaconda.Tweet) {
log.Printf("Tweet: %s", tw.Text)
var err error
if urlRegexp == nil {
urlRegexp, err = regexp.Compile(kUrlRegexp)
if err != nil {
log.Fatal(err)
}
}
text := tw.Text
text = urlRegexp.ReplaceAllString(text, "")
rs, err := mecab.Parse(text)
if err != nil {
log.Fatal(err)
}
strs := make([]string, len(rs))
for i, r := range rs {
strs[i] = r.Surface
}
log.Print(strs)
alphas := 0
for _, r := range rs {
rlen := len([]rune(r.Surface))
if count(kAlphabet, r.Surface) > (rlen / 2) {
alphas++
}
}
if alphas > (len(rs) / 2) {
return
}
candidates := make([]string, 0)
for _, r := range rs {
if contains(kStopWords, r.Surface) {
return
}
rlen := len([]rune(r.Surface))
syms := count(kSymbols, r.Surface)
if rlen <= 1 || (syms) > (rlen/2) {
continue
}
f := r.Feature
if !(r.Pos == "名詞" && !strings.Contains(f, "接尾") &&
!strings.Contains(f, "代名詞") &&
!strings.Contains(f, "接頭詞") &&
!strings.Contains(f, "形容動詞語幹")) {
continue
}
candidates = append(candidates, r.Surface)
}
if len(candidates) <= 0 {
return
}
c := candidates[rand.Intn(len(candidates))]
log.Printf("%s as a Service\n", c)
t, err := api.PostTweet(c+" as a Service", nil)
if err != nil {
log.Println(err)
}
log.Println(t)
os.Exit(0)
}
func (g *gweet) tweet(api *anaconda.TwitterApi,
text string, files []string, lewd bool) (tweetUrl string, err error) {
log.Printf(`Tweeting {"%s", %v, lewd=%v}.`+"\n", text, files, lewd)
var ids string
var data []byte
for _, filePath := range files {
log.Println("Uploading", filePath)
// TODO: refuse files larger than 15mb for vids and 5mb for images
data, err = ioutil.ReadFile(filePath)
if err != nil {
return
}
/*mime*/ meme := http.DetectContentType(data)
log.Println(meme)
if !strings.HasPrefix( /*mime*/ meme, "image") {
var media anaconda.ChunkedMedia
var videoMedia anaconda.VideoMedia
// TODO: do not read entire file to memory
media, err = api.UploadVideoInit(len(data), "video/mp4")
if err != nil {
return
}
chunkIndex := 0
for i := 0; i < len(data); i += 5242879 {
log.Println("Chunk", chunkIndex)
err = api.UploadVideoAppend(media.MediaIDString, chunkIndex,
base64.StdEncoding.EncodeToString(
data[i:int(math.Min(5242879.0, float64(len(data))))],
),
)
if err != nil {
return
}
chunkIndex++
}
videoMedia, err = api.UploadVideoFinalize(media.MediaIDString)
if err != nil {
return
}
ids += videoMedia.MediaIDString
ids += ","
} else {
var media anaconda.Media
media, err = api.UploadMedia(
base64.StdEncoding.EncodeToString(data))
ids += media.MediaIDString
ids += ","
}
if err != nil {
return
}
}
ids = ids[:len(ids)-1]
log.Println("media_ids:", ids)
v := url.Values{}
v.Set("media_ids", ids)
v.Set("possibly_sensitive", strconv.FormatBool(lewd))
tweet, err := api.PostTweet(text, v)
if err != nil {
return
}
tweetUrl = fmt.Sprintf("https://twitter.com/%s/status/%s",
tweet.User.ScreenName, tweet.IdStr)
return
}
