netmoose
/
ssender
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Compare commits

base: netmoose:4c167c5ba76ceb3fa71887d2eeee0c8408195657
Branches Tags
netmoose:develop
netmoose:main
..
compare: netmoose:48fe506f8d143a409cd7ce8d24f6673015444754
Branches Tags
netmoose:develop
netmoose:main

No commits in common. '4c167c5ba76ceb3fa71887d2eeee0c8408195657' and '48fe506f8d143a409cd7ce8d24f6673015444754' have entirely different histories.
4c167c5ba7 ... 48fe506f8d

5 changed files with 171 additions and 210 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats
  1. 100
      internal/db/db.go
  2. 52
      internal/models/config.go
  3. 27
      internal/rss/rss.go
  4. 48
      internal/send/send.go
  5. 146
      main.go

100
internal/db/db.go
Unescape View File

@ -1,100 +0,0 @@
package db
import (
"encoding/json"
"log"
"ssender/internal/models"
"github.com/boltdb/bolt"
)
func InitDb(rss models.Rss2, dbpath string) error {
log.Println("Initialize DB")
db, err := bolt.Open(dbpath, 0600, nil)
if err != nil {
log.Fatal(err)
}
defer db.Close()
err = db.Update(func(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte("rss"))
if err != nil {
return err
}
for _, v := range rss.ItemList {
encoded, err := json.Marshal(v)
if err != nil {
return err
}
err = b.Put([]byte(v.Link), encoded)
if err != nil {
return err
}
}
return nil
})
if err != nil {
return err
}
return nil
}
func FindItems(rss models.Rss2, dbpath string) (*models.SendItems, error) {
var sendItems models.SendItems
db, err := bolt.Open(dbpath, 0600, nil)
if err != nil {
return nil, err
}
defer db.Close()
for _, v := range rss.ItemList {
err = db.View(func(tx *bolt.Tx) error {
// Assume bucket exists and has keys
b := tx.Bucket([]byte("rss"))
c := b.Cursor()
flag := false
for key, _ := c.First(); key != nil; key, _ = c.Next() {
if v.Link == string(key) {
flag = true
break
}
}
if flag {
sendItems.ItemList = append(sendItems.ItemList, v)
}
return nil
})
if err != nil {
return nil, err
}
}
return &sendItems, nil
}
func UpdateDb(dbpath string, senditems *models.SendItems) error {
log.Println("Update DB")
db, err := bolt.Open(dbpath, 0600, nil)
if err != nil {
log.Fatal(err)
}
defer db.Close()
err = db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("rss"))
for _, v := range senditems.ItemList {
encoded, err := json.Marshal(v)
if err != nil {
return err
}
err = b.Put([]byte(v.Link), encoded)
if err != nil {
return err
}
}
return nil
})
if err != nil {
return err
}
return nil
}

52
internal/models/config.go
Unescape View File

@ -1,5 +1,12 @@
package models package models
import (
"log"
"github.com/SevereCloud/vksdk/v2/api"
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)
type Config struct { type Config struct {
Dbpath string `yaml:"dbpath"` Dbpath string `yaml:"dbpath"`
Telegram struct { Telegram struct {
@ -13,4 +20,49 @@ type Config struct {
Token string `yaml:"token"` Token string `yaml:"token"`
OwnerId int64 `yaml:"ownerid"` OwnerId int64 `yaml:"ownerid"`
} `yaml:"vk"` } `yaml:"vk"`
Facebook struct {
Send bool `yaml:"send"`
Token string `yaml:"token"`
} `yaml:"facebook"`
}
func (config Config) RunSend(senditems SendItems) {
for _, v := range senditems.ItemList {
if config.Telegram.Send {
log.Println("Send to telegram")
bot, err := tgbotapi.NewBotAPI(config.Telegram.Token)
if err != nil {
log.Panic(err)
}
bot.Debug = config.Telegram.SendDebug
// s := "<b>" + string(v.Title) + "</b>\n" + html.UnescapeString(string(v.Description)) +
// "\nhttps://t.me/iv?url=" + v.Link + "&rhash=da76512d0ff2a2" +
// "\n\nСсылка на пост: " + v.Link
msg := tgbotapi.NewMessage(config.Telegram.ChatId, v.Link)
msg.ParseMode = "Html"
_, err = bot.Send(msg)
if err != nil {
log.Panic(err)
}
log.Println("Sended to telegram")
}
if config.VK.Send {
log.Println("Send to VK")
vk := api.NewVK(config.VK.Token)
_, err := vk.WallPost(api.Params{
"owner_id": config.VK.OwnerId,
"attachments": v.Link,
})
if err != nil {
log.Fatal(err)
}
log.Println("Sended to VK")
}
if config.Facebook.Send {
log.Println("Send to Facebook")
log.Println("Sending to facebook is not implemented yet")
}
}
} }

27
internal/rss/rss.go
Unescape View File

@ -1,27 +0,0 @@
package rss
import (
"encoding/xml"
"os"
"ssender/internal/models"
)
func NewRSS(rssPath string) (*models.Rss2, error) {
rss := &models.Rss2{}
// Open rss2 file
file, err := os.Open(rssPath)
if err != nil {
return nil, err
}
defer file.Close()
d := xml.NewDecoder(file)
// Start RSS decoding from file
if err := d.Decode(&rss); err != nil {
return nil, err
}
return rss, nil
}

48
internal/send/send.go
Unescape View File

@ -1,48 +0,0 @@
package send
import (
"log"
"ssender/internal/models"
"github.com/SevereCloud/vksdk/v2/api"
tgbotapi "github.com/go-telegram-bot-api/telegram-bot-api/v5"
)
func RunSend(senditems *models.SendItems, config models.Config) error {
for _, v := range senditems.ItemList {
if config.Telegram.Send {
log.Println("Send to telegram")
bot, err := tgbotapi.NewBotAPI(config.Telegram.Token)
if err != nil {
return err
}
bot.Debug = config.Telegram.SendDebug
// s := "<b>" + string(v.Title) + "</b>\n" + html.UnescapeString(string(v.Description)) +
// "\nhttps://t.me/iv?url=" + v.Link + "&rhash=da76512d0ff2a2" +
// "\n\nСсылка на пост: " + v.Link
msg := tgbotapi.NewMessage(config.Telegram.ChatId, v.Link)
msg.ParseMode = "Html"
_, err = bot.Send(msg)
if err != nil {
return err
}
log.Println("Sended to telegram")
}
if config.VK.Send {
log.Println("Send to VK")
vk := api.NewVK(config.VK.Token)
_, err := vk.WallPost(api.Params{
"owner_id": config.VK.OwnerId,
"attachments": v.Link,
})
if err != nil {
return err
}
log.Println("Sended to VK")
}
}
return nil
}

146
main.go
Unescape View File

@ -1,13 +1,14 @@
package main package main
import ( import (
"encoding/json"
"encoding/xml"
"log" "log"
"os" "os"
"ssender/internal/config" "ssender/internal/config"
"ssender/internal/db" "ssender/internal/models"
"ssender/internal/rss"
"ssender/internal/send"
"github.com/boltdb/bolt"
"github.com/jessevdk/go-flags" "github.com/jessevdk/go-flags"
) )
@ -17,9 +18,108 @@ type Options struct {
InitDB bool `short:"i" long:"initdb" description:"Run initialize from current file"` InitDB bool `short:"i" long:"initdb" description:"Run initialize from current file"`
} }
var ( var ConfigPath = "/etc/ssender/config.yml"
ConfigPath = "/etc/ssender/config.yml"
) func NewRSS(rssPath string) (*models.Rss2, error) {
rss := &models.Rss2{}
// Open rss2 file
file, err := os.Open(rssPath)
if err != nil {
return nil, err
}
defer file.Close()
d := xml.NewDecoder(file)
// Start RSS decoding from file
if err := d.Decode(&rss); err != nil {
return nil, err
}
return rss, nil
}
var senditems models.SendItems
func FindItems(rss models.Rss2, dbpath string) {
db, err := bolt.Open(dbpath, 0600, nil)
if err != nil {
log.Fatal(err)
}
defer db.Close()
for _, v := range rss.ItemList {
db.View(func(tx *bolt.Tx) error {
// Assume bucket exists and has keys
b := tx.Bucket([]byte("rss"))
c := b.Cursor()
flag := false
for key, _ := c.First(); key != nil; key, _ = c.Next() {
if v.Link == string(key) {
flag = true
break
}
}
if flag {
senditems.ItemList = append(senditems.ItemList, v)
}
return nil
})
}
}
func InitDb(rss models.Rss2, dbpath string) {
log.Println("Initialize DB")
db, err := bolt.Open(dbpath, 0600, nil)
if err != nil {
log.Fatal(err)
}
defer db.Close()
db.Update(func(tx *bolt.Tx) error {
b, err := tx.CreateBucketIfNotExists([]byte("rss"))
if err != nil {
return err
}
for _, v := range rss.ItemList {
encoded, err := json.Marshal(v)
if err != nil {
return err
}
err = b.Put([]byte(v.Link), encoded)
if err != nil {
return err
}
}
return nil
})
}
func UpdateDb(dbpath string) {
log.Println("Update DB")
db, err := bolt.Open(dbpath, 0600, nil)
if err != nil {
log.Fatal(err)
}
defer db.Close()
db.Update(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("rss"))
for _, v := range senditems.ItemList {
encoded, err := json.Marshal(v)
if err != nil {
return err
}
err = b.Put([]byte(v.Link), encoded)
if err != nil {
return err
}
}
return nil
})
}
func main() { func main() {
log.Println("Run processing") log.Println("Run processing")
@ -39,11 +139,10 @@ func main() {
} }
log.Println("Flags processed") log.Println("Flags processed")
if options.ConfigPath == "" { if options.ConfigPath != "" {
log.Fatalf("Config path not found in options!")
}
log.Printf("Config from: %s\n", options.ConfigPath) log.Printf("Config from: %s\n", options.ConfigPath)
ConfigPath = options.ConfigPath ConfigPath = options.ConfigPath
}
// Get config // Get config
cfg, err := config.NewConfig(ConfigPath) cfg, err := config.NewConfig(ConfigPath)
@ -54,37 +153,22 @@ func main() {
// Parse rss file // Parse rss file
log.Printf("Parse file %s \n", options.FileParse) log.Printf("Parse file %s \n", options.FileParse)
rss, err := rss.NewRSS(options.FileParse) rss, err := NewRSS(options.FileParse)
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
if options.InitDB { if options.InitDB {
err := db.InitDb(*rss, cfg.Dbpath) InitDb(*rss, cfg.Dbpath)
if err != nil { } else {
log.Fatal(err)
}
}
//Find new items //Find new items
sendItems, err := db.FindItems(*rss, cfg.Dbpath) FindItems(*rss, cfg.Dbpath)
if err != nil {
log.Fatal(err)
}
if len(sendItems.ItemList) > 0 { if len(senditems.ItemList) > 0 {
// Run send data depended on configuration options // Run send data depended on configuration options
log.Println("Run send process") log.Println("Run send process")
err := send.RunSend(sendItems, *cfg) cfg.RunSend(senditems)
if err != nil { UpdateDb(cfg.Dbpath)
log.Fatal(err)
}
// Run update db
err = db.UpdateDb(cfg.Dbpath, sendItems)
if err != nil {
log.Fatal(err)
} }
} }
log.Println("End processing") log.Println("End processing")
} }

Write Preview
Loading…
Cancel
Save