mirror of
https://git.klmp200.net/ALFRED/ALFRED.git
synced 2025-01-18 18:46:44 +01:00
305 lines
8.2 KiB
Go
305 lines
8.2 KiB
Go
/*
|
|
* @Authors: Amalvy Arthur, Bartuccio Antoine
|
|
*/
|
|
|
|
// This module uses a property named "subscribed_chats" in the shared Users structure.
|
|
// It consists of a list of chatID as a string, chatID are separated by ":" (unix PATH style)
|
|
|
|
// This module uses a property named "saved_messages" in the shared Chats structure
|
|
// It consists of a slice of string
|
|
|
|
package commands
|
|
|
|
import (
|
|
"encoding/json"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"../shared"
|
|
tb "gopkg.in/tucnak/telebot.v2"
|
|
)
|
|
|
|
type userSubscription struct {
|
|
ChatID int64
|
|
AutoNotify bool
|
|
}
|
|
|
|
func getUserSubscribedChats(username string) []userSubscription {
|
|
|
|
serializedSubscriptions, exists := shared.Users.Get(username, "subscribed_chats")
|
|
if !exists {
|
|
return []userSubscription{}
|
|
}
|
|
|
|
subscriptions := []userSubscription{}
|
|
for _, chatID := range strings.Split(serializedSubscriptions, ":") {
|
|
if id, err := strconv.ParseInt(chatID, 10, 64); err == nil {
|
|
subscriptions = append(subscriptions, userSubscription{
|
|
ChatID: id,
|
|
AutoNotify: true,
|
|
})
|
|
}
|
|
}
|
|
|
|
return subscriptions
|
|
}
|
|
|
|
func setUserSubscribedChats(username string, subscriptions []userSubscription) {
|
|
|
|
subs := make([]string, len(subscriptions))
|
|
for i, sub := range subscriptions {
|
|
subs[i] = strconv.FormatInt(sub.ChatID, 10)
|
|
}
|
|
|
|
shared.Users.Set(username, "subscribed_chats", strings.Join(subs, ":"))
|
|
}
|
|
|
|
func getPublishedMessages(chatID int64) []tb.Message {
|
|
messages := []tb.Message{}
|
|
|
|
serializedMessages, exists := shared.ChatData.Get(chatID, "published_messages")
|
|
if !exists {
|
|
return messages
|
|
}
|
|
|
|
if _, ok := serializedMessages.(string); !ok {
|
|
return messages
|
|
}
|
|
|
|
if json.Unmarshal([]byte(serializedMessages.(string)), &messages) != nil {
|
|
return []tb.Message{}
|
|
}
|
|
|
|
return messages
|
|
}
|
|
|
|
func setPublishedMessages(chatID int64, messages []tb.Message) {
|
|
data, err := json.Marshal(messages)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
shared.ChatData.Set(chatID, "published_messages", string(data))
|
|
}
|
|
|
|
// Subscribe user sending the command to the current chat
|
|
// Command syntax : /subscribe
|
|
func Subscribe(m *tb.Message) {
|
|
|
|
if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup {
|
|
shared.Bot.Send(m.Chat, "Cette commande n'est pas autorisée pour ce type de chat")
|
|
return
|
|
}
|
|
|
|
if m.Sender.Username == "" {
|
|
shared.Bot.Send(m.Chat, "Il faut avoir enregistré un username pour pouvoir utiliser cette fonction")
|
|
return
|
|
}
|
|
|
|
subscriptions := getUserSubscribedChats(m.Sender.Username)
|
|
alreadySuscribed := false
|
|
|
|
for _, sub := range subscriptions {
|
|
if sub.ChatID == m.Chat.ID {
|
|
alreadySuscribed = true
|
|
break
|
|
}
|
|
}
|
|
|
|
if alreadySuscribed {
|
|
shared.Bot.Send(m.Chat, "Vous êtes déjà abonné à ce chat : "+m.Chat.Title)
|
|
return
|
|
}
|
|
|
|
shared.Bot.Send(m.Chat, "Abonnement au chat : "+m.Chat.Title)
|
|
subscriptions = append(subscriptions, userSubscription{
|
|
ChatID: m.Chat.ID,
|
|
AutoNotify: true,
|
|
})
|
|
|
|
setUserSubscribedChats(m.Sender.Username, subscriptions)
|
|
}
|
|
|
|
// Unsubscribe user sending the command from the current chat
|
|
// Command syntax : /unsubscribe
|
|
func Unsubscribe(m *tb.Message) {
|
|
|
|
if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup {
|
|
shared.Bot.Send(m.Chat, "Cette commande n'est pas autorisée pour ce type de chat")
|
|
return
|
|
}
|
|
|
|
if m.Sender.Username == "" {
|
|
shared.Bot.Send(m.Chat, "Il faut avoir enregistré un username pour pouvoir utiliser cette fonction")
|
|
return
|
|
}
|
|
|
|
subscriptions := getUserSubscribedChats(m.Sender.Username)
|
|
|
|
if len(subscriptions) == 0 {
|
|
shared.Bot.Send(m.Chat, "Vous n'êtes abonnés à aucun chat")
|
|
return
|
|
}
|
|
|
|
filteredSubscriptions := []userSubscription{}
|
|
wasSuscribed := false
|
|
|
|
for _, sub := range subscriptions {
|
|
if sub.ChatID == m.Chat.ID {
|
|
wasSuscribed = true
|
|
continue
|
|
}
|
|
filteredSubscriptions = append(filteredSubscriptions, sub)
|
|
}
|
|
|
|
if !wasSuscribed {
|
|
shared.Bot.Send(m.Chat, "Vous n'êtes pas abonné au chat : "+m.Chat.Title)
|
|
return
|
|
}
|
|
|
|
shared.Bot.Send(m.Chat, "désabonnement du chat : "+m.Chat.Title)
|
|
|
|
setUserSubscribedChats(m.Sender.Username, filteredSubscriptions)
|
|
}
|
|
|
|
// ListSubscribers List all subscribers of the current chat
|
|
// Command syntax : /listsubscribers
|
|
func ListSubscribers(m *tb.Message) {
|
|
if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup {
|
|
shared.Bot.Send(m.Chat, "Cette commande n'est pas autorisée pour ce type de chat")
|
|
return
|
|
}
|
|
subscribers := m.Chat.Title + " subscribers : \n\n"
|
|
for _, subscriber := range getSubscribers(m.Chat.ID) {
|
|
subscribers = subscribers + "- " + subscriber + "\n"
|
|
}
|
|
shared.Bot.Send(m.Chat, subscribers)
|
|
}
|
|
|
|
// Publish a message from the current chat
|
|
// Command syntax (while replying to a message) : /publish
|
|
func Publish(m *tb.Message) {
|
|
if m.ReplyTo == nil {
|
|
shared.Bot.Send(m.Chat, "Veuillez répondre à un message pour le publier")
|
|
return
|
|
}
|
|
|
|
if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup {
|
|
shared.Bot.Send(m.Chat, "Cette commande n'est pas autorisée pour ce type de chat")
|
|
return
|
|
}
|
|
|
|
defer shared.Bot.Send(m.Chat, "Message publié : "+m.ReplyTo.Text)
|
|
savedMessages := getPublishedMessages(m.Chat.ID)
|
|
setPublishedMessages(m.Chat.ID, append(savedMessages, *m.ReplyTo))
|
|
|
|
}
|
|
|
|
// Unpublish remove a message from published messages in the current chat
|
|
// Command syntax (while replying to a message) : /unpublish
|
|
func Unpublish(m *tb.Message) {
|
|
|
|
if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup {
|
|
shared.Bot.Send(m.Chat, "Cette commande n'est pas autorisée pour ce type de chat")
|
|
return
|
|
}
|
|
|
|
if m.ReplyTo == nil {
|
|
shared.Bot.Send(m.Chat, "Veuillez répondre à un message pour le dépublier")
|
|
return
|
|
}
|
|
|
|
if !m.ReplyTo.IsForwarded() {
|
|
shared.Bot.Send(m.Chat, "Ce message ne peut pas avoir été publié")
|
|
return
|
|
}
|
|
|
|
publishedMessages := getPublishedMessages(m.Chat.ID)
|
|
filteredPublishedMessages := []tb.Message{}
|
|
found := false
|
|
for _, message := range publishedMessages {
|
|
// You can't just compare messages id because
|
|
// when retrieving, the newly send message
|
|
// has a different ID from the one stored so you can't detect that's
|
|
// it's in the database except if you find the original message
|
|
// which is very unlikely to happen
|
|
// As a workaround, we check the original sender, original unix time
|
|
// and associated text
|
|
if message.Sender.ID == m.ReplyTo.OriginalSender.ID &&
|
|
message.Unixtime == int64(m.ReplyTo.OriginalUnixtime) &&
|
|
message.Text == m.ReplyTo.Text {
|
|
found = true
|
|
continue
|
|
}
|
|
filteredPublishedMessages = append(filteredPublishedMessages, message)
|
|
}
|
|
|
|
if !found {
|
|
shared.Bot.Send(m.Chat, "Ce message n'a jamais été publié")
|
|
return
|
|
}
|
|
|
|
setPublishedMessages(m.Chat.ID, filteredPublishedMessages)
|
|
shared.Bot.Send(m.Chat, "Message supprimé des publication")
|
|
}
|
|
|
|
// Retrieve If performed in MP : retrieve all messages from all subscribed sources for the user
|
|
// If performed in Group Chat : retrieved all published messages for this chat
|
|
// Command syntax : /retrieve
|
|
func Retrieve(m *tb.Message) {
|
|
chatList := []userSubscription{}
|
|
hasMessage := false
|
|
|
|
if m.Chat.Type != tb.ChatGroup && m.Chat.Type != tb.ChatSuperGroup && m.Chat.Type != tb.ChatPrivate {
|
|
shared.Bot.Send(m.Chat, "Cette commande n'est pas autorisée pour ce type de chat")
|
|
return
|
|
}
|
|
|
|
if m.Chat.Type == tb.ChatPrivate {
|
|
|
|
if m.Sender.Username == "" {
|
|
shared.Bot.Send(m.Chat, "Il faut avoir enregistré un username pour pouvoir utiliser cette fonction")
|
|
return
|
|
}
|
|
|
|
chatList = getUserSubscribedChats(m.Sender.Username)
|
|
}
|
|
|
|
if m.Chat.Type == tb.ChatGroup || m.Chat.Type == tb.ChatSuperGroup {
|
|
chatList = append(chatList, userSubscription{ChatID: m.Chat.ID})
|
|
}
|
|
|
|
shared.Bot.Send(m.Chat, "--- Messages publiés ---")
|
|
|
|
for _, sub := range chatList {
|
|
messages := getPublishedMessages(sub.ChatID)
|
|
if len(messages) > 0 {
|
|
hasMessage = true
|
|
}
|
|
for _, message := range messages {
|
|
shared.Bot.Forward(m.Chat, &message)
|
|
}
|
|
}
|
|
|
|
if !hasMessage {
|
|
shared.Bot.Send(m.Chat, "Aucun message publié")
|
|
}
|
|
|
|
shared.Bot.Send(m.Chat, "--- Messages publiés ---")
|
|
}
|
|
|
|
// Get all users subscribed to the provided channel
|
|
func getSubscribers(chatID int64) []string {
|
|
var subscribers []string
|
|
for _, username := range shared.Users.GetUsernames() {
|
|
subscriptions := getUserSubscribedChats(username)
|
|
for _, sub := range subscriptions {
|
|
if sub.ChatID == chatID {
|
|
subscribers = append(subscribers, username)
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return subscribers
|
|
}
|