Compare commits
1 commit
master
...
message-ni
| Author | SHA1 | Date | |
|---|---|---|---|
 Bohdan Horbeshko
|
b5920822c4 |
2
.gitignore
vendored
2
.gitignore
vendored
|
|
@ -3,5 +3,3 @@ telegabber
|
|||
sessions/
|
||||
session.dat
|
||||
session.dat.new
|
||||
release/
|
||||
tdlib/
|
||||
|
|
|
|||
36
Dockerfile
36
Dockerfile
|
|
@ -1,36 +0,0 @@
|
|||
FROM golang:1.19-bookworm AS base
|
||||
|
||||
RUN apt-get update
|
||||
run apt-get install -y libssl-dev cmake build-essential gperf libz-dev make git
|
||||
|
||||
FROM base AS tdlib
|
||||
|
||||
ARG TD_COMMIT
|
||||
ARG MAKEOPTS
|
||||
RUN git clone https://github.com/tdlib/td /src/
|
||||
RUN git -C /src/ checkout "${TD_COMMIT}"
|
||||
RUN mkdir build
|
||||
WORKDIR /build/
|
||||
RUN cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/compiled/ /src/
|
||||
RUN cmake --build . ${MAKEOPTS}
|
||||
RUN make install
|
||||
|
||||
FROM base AS cache
|
||||
ARG VERSION
|
||||
COPY --from=tdlib /compiled/ /usr/local/
|
||||
COPY ./ /src
|
||||
RUN git -C /src checkout "${VERSION}"
|
||||
WORKDIR /src
|
||||
RUN go get
|
||||
|
||||
FROM cache AS build
|
||||
ARG MAKEOPTS
|
||||
WORKDIR /src
|
||||
RUN make ${MAKEOPTS}
|
||||
|
||||
FROM scratch AS telegabber
|
||||
COPY --from=build /src/release/telegabber /usr/local/bin/
|
||||
ENTRYPOINT ["/usr/local/bin/telegabber"]
|
||||
|
||||
FROM scratch AS binaries
|
||||
COPY --from=telegabber /usr/local/bin/telegabber /
|
||||
15
Makefile
15
Makefile
|
|
@ -1,25 +1,12 @@
|
|||
.PHONY: all test
|
||||
|
||||
COMMIT := $(shell git rev-parse --short HEAD)
|
||||
TD_COMMIT := "5bbfc1cf5dab94f82e02f3430ded7241d4653551"
|
||||
VERSION := "v1.9.6"
|
||||
MAKEOPTS := "-j4"
|
||||
|
||||
all:
|
||||
mkdir -p release
|
||||
go build -ldflags "-X main.commit=${COMMIT}" -o release/telegabber
|
||||
go build -ldflags "-X main.commit=${COMMIT}" -o telegabber
|
||||
|
||||
test:
|
||||
go test -v ./config ./ ./telegram ./xmpp ./xmpp/gateway ./persistence ./telegram/formatter ./badger
|
||||
|
||||
lint:
|
||||
$(GOPATH)/bin/golint ./...
|
||||
|
||||
build_indocker:
|
||||
docker build --build-arg "TD_COMMIT=${TD_COMMIT}" --build-arg "VERSION=${VERSION}" --build-arg "MAKEOPTS=${MAKEOPTS}" --output=release --target binaries .
|
||||
|
||||
build_indocker_staging:
|
||||
DOCKER_BUILDKIT=1 docker build --build-arg "TD_COMMIT=${TD_COMMIT}" --build-arg "MAKEOPTS=${MAKEOPTS}" --network host --output=release --target binaries -f staging.Dockerfile .
|
||||
|
||||
build_tdlib:
|
||||
DOCKER_BUILDKIT=1 docker build --build-arg "TD_COMMIT=${TD_COMMIT}" --build-arg "MAKEOPTS=${MAKEOPTS}" --output=tdlib --target binaries -f tdlib.Dockerfile .
|
||||
|
|
|
|||
1
go.mod
1
go.mod
|
|
@ -34,4 +34,3 @@ require (
|
|||
)
|
||||
|
||||
replace gosrc.io/xmpp => dev.narayana.im/narayana/go-xmpp v0.0.0-20220524203317-306b4ff58e8f
|
||||
replace github.com/zelenin/go-tdlib => dev.narayana.im/narayana/go-tdlib v0.0.0-20240124222245-b4c12addb061
|
||||
|
|
|
|||
6
go.sum
6
go.sum
|
|
@ -1,10 +1,4 @@
|
|||
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
|
||||
dev.narayana.im/narayana/go-tdlib v0.0.0-20230730021136-47da33180615 h1:RRUZJSro+k8FkazNx7QEYLVoO4wZtchvsd0Y2RBWjeU=
|
||||
dev.narayana.im/narayana/go-tdlib v0.0.0-20230730021136-47da33180615/go.mod h1:Xs8fXbk5n7VaPyrSs9DP7QYoBScWYsjX+lUcWmx1DIU=
|
||||
dev.narayana.im/narayana/go-tdlib v0.0.0-20231111182840-bc2f985e6268 h1:NCbc2bYuUGQsb/3z5SCIia3N34Ktwq3FwaUAfgF/WEU=
|
||||
dev.narayana.im/narayana/go-tdlib v0.0.0-20231111182840-bc2f985e6268/go.mod h1:Xs8fXbk5n7VaPyrSs9DP7QYoBScWYsjX+lUcWmx1DIU=
|
||||
dev.narayana.im/narayana/go-tdlib v0.0.0-20240124222245-b4c12addb061 h1:CWAQT74LwQne/3Po5KXDvudu3N0FBWm3XZZZhtl5j2w=
|
||||
dev.narayana.im/narayana/go-tdlib v0.0.0-20240124222245-b4c12addb061/go.mod h1:Xs8fXbk5n7VaPyrSs9DP7QYoBScWYsjX+lUcWmx1DIU=
|
||||
dev.narayana.im/narayana/go-xmpp v0.0.0-20220524203317-306b4ff58e8f h1:6249ajbMjgYz53Oq0IjTvjHXbxTfu29Mj1J/6swRHs4=
|
||||
dev.narayana.im/narayana/go-xmpp v0.0.0-20220524203317-306b4ff58e8f/go.mod h1:L3NFMqYOxyLz3JGmgFyWf7r9htE91zVGiK40oW4RwdY=
|
||||
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@ package persistence
|
|||
import (
|
||||
"github.com/pkg/errors"
|
||||
"io/ioutil"
|
||||
"sync"
|
||||
"time"
|
||||
|
||||
"dev.narayana.im/narayana/telegabber/yamldb"
|
||||
|
|
@ -35,18 +34,14 @@ type SessionsMap struct {
|
|||
|
||||
// Session is a key-values subtree
|
||||
type Session struct {
|
||||
Login string `yaml:":login"`
|
||||
Timezone string `yaml:":timezone"`
|
||||
KeepOnline bool `yaml:":keeponline"`
|
||||
RawMessages bool `yaml:":rawmessages"`
|
||||
AsciiArrows bool `yaml:":asciiarrows"`
|
||||
OOBMode bool `yaml:":oobmode"`
|
||||
Carbons bool `yaml:":carbons"`
|
||||
HideIds bool `yaml:":hideids"`
|
||||
Receipts bool `yaml:":receipts"`
|
||||
NativeEdits bool `yaml:":nativeedits"`
|
||||
IgnoredChats []int64 `yaml:":ignoredchats"`
|
||||
ignoredChatsMap map[int64]bool `yaml:"-"`
|
||||
Login string `yaml:":login"`
|
||||
Timezone string `yaml:":timezone"`
|
||||
KeepOnline bool `yaml:":keeponline"`
|
||||
RawMessages bool `yaml:":rawmessages"`
|
||||
AsciiArrows bool `yaml:":asciiarrows"`
|
||||
OOBMode bool `yaml:":oobmode"`
|
||||
Carbons bool `yaml:":carbons"`
|
||||
HideIds bool `yaml:":hideids"`
|
||||
}
|
||||
|
||||
var configKeys = []string{
|
||||
|
|
@ -57,26 +52,17 @@ var configKeys = []string{
|
|||
"oobmode",
|
||||
"carbons",
|
||||
"hideids",
|
||||
"receipts",
|
||||
"nativeedits",
|
||||
}
|
||||
|
||||
var sessionDB *SessionsYamlDB
|
||||
var sessionsLock sync.Mutex
|
||||
|
||||
// SessionMarshaller implementation for YamlDB
|
||||
func SessionMarshaller() ([]byte, error) {
|
||||
cleanedMap := SessionsMap{}
|
||||
emptySessionsMap(&cleanedMap)
|
||||
|
||||
sessionsLock.Lock()
|
||||
defer sessionsLock.Unlock()
|
||||
for jid, session := range sessionDB.Data.Sessions {
|
||||
if session.Login != "" {
|
||||
session.IgnoredChats = make([]int64, 0, len(session.ignoredChatsMap))
|
||||
for chatID := range session.ignoredChatsMap {
|
||||
session.IgnoredChats = append(session.IgnoredChats, chatID)
|
||||
}
|
||||
cleanedMap.Sessions[jid] = session
|
||||
}
|
||||
}
|
||||
|
|
@ -118,16 +104,6 @@ func initYamlDB(path string, dataPtr *SessionsMap) (*SessionsYamlDB, error) {
|
|||
emptySessionsMap(dataPtr)
|
||||
}
|
||||
|
||||
// convert ignored users slice to map
|
||||
for jid, session := range dataPtr.Sessions {
|
||||
session.ignoredChatsMap = make(map[int64]bool)
|
||||
for _, chatID := range session.IgnoredChats {
|
||||
session.ignoredChatsMap[chatID] = true
|
||||
}
|
||||
session.IgnoredChats = nil
|
||||
dataPtr.Sessions[jid] = session
|
||||
}
|
||||
|
||||
return &SessionsYamlDB{
|
||||
YamlDB: yamldb.YamlDB{
|
||||
Path: path,
|
||||
|
|
@ -139,13 +115,6 @@ func initYamlDB(path string, dataPtr *SessionsMap) (*SessionsYamlDB, error) {
|
|||
|
||||
// Get retrieves a session value
|
||||
func (s *Session) Get(key string) (string, error) {
|
||||
sessionsLock.Lock()
|
||||
defer sessionsLock.Unlock()
|
||||
|
||||
return s.get(key)
|
||||
}
|
||||
|
||||
func (s *Session) get(key string) (string, error) {
|
||||
switch key {
|
||||
case "timezone":
|
||||
return s.Timezone, nil
|
||||
|
|
@ -161,10 +130,6 @@ func (s *Session) get(key string) (string, error) {
|
|||
return fromBool(s.Carbons), nil
|
||||
case "hideids":
|
||||
return fromBool(s.HideIds), nil
|
||||
case "receipts":
|
||||
return fromBool(s.Receipts), nil
|
||||
case "nativeedits":
|
||||
return fromBool(s.NativeEdits), nil
|
||||
}
|
||||
|
||||
return "", errors.New("Unknown session property")
|
||||
|
|
@ -172,12 +137,9 @@ func (s *Session) get(key string) (string, error) {
|
|||
|
||||
// ToMap converts the session to a map
|
||||
func (s *Session) ToMap() map[string]string {
|
||||
sessionsLock.Lock()
|
||||
defer sessionsLock.Unlock()
|
||||
|
||||
m := make(map[string]string)
|
||||
for _, configKey := range configKeys {
|
||||
value, _ := s.get(configKey)
|
||||
value, _ := s.Get(configKey)
|
||||
m[configKey] = value
|
||||
}
|
||||
|
||||
|
|
@ -186,9 +148,6 @@ func (s *Session) ToMap() map[string]string {
|
|||
|
||||
// Set sets a session value
|
||||
func (s *Session) Set(key string, value string) (string, error) {
|
||||
sessionsLock.Lock()
|
||||
defer sessionsLock.Unlock()
|
||||
|
||||
switch key {
|
||||
case "timezone":
|
||||
s.Timezone = value
|
||||
|
|
@ -235,20 +194,6 @@ func (s *Session) Set(key string, value string) (string, error) {
|
|||
}
|
||||
s.HideIds = b
|
||||
return value, nil
|
||||
case "receipts":
|
||||
b, err := toBool(value)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
s.Receipts = b
|
||||
return value, nil
|
||||
case "nativeedits":
|
||||
b, err := toBool(value)
|
||||
if err != nil {
|
||||
return "", err
|
||||
}
|
||||
s.NativeEdits = b
|
||||
return value, nil
|
||||
}
|
||||
|
||||
return "", errors.New("Unknown session property")
|
||||
|
|
@ -265,51 +210,6 @@ func (s *Session) TimezoneToLocation() *time.Location {
|
|||
return zeroLocation
|
||||
}
|
||||
|
||||
// IgnoreChat adds a chat id to ignore list, returns false if already ignored
|
||||
func (s *Session) IgnoreChat(chatID int64) bool {
|
||||
sessionsLock.Lock()
|
||||
defer sessionsLock.Unlock()
|
||||
|
||||
if s.ignoredChatsMap == nil {
|
||||
s.ignoredChatsMap = make(map[int64]bool)
|
||||
} else if _, ok := s.ignoredChatsMap[chatID]; ok {
|
||||
return false
|
||||
}
|
||||
|
||||
s.ignoredChatsMap[chatID] = true
|
||||
return true
|
||||
}
|
||||
|
||||
// UnignoreChat removes a chat id from ignore list, returns false if not already ignored
|
||||
func (s *Session) UnignoreChat(chatID int64) bool {
|
||||
sessionsLock.Lock()
|
||||
defer sessionsLock.Unlock()
|
||||
|
||||
if s.ignoredChatsMap == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
if _, ok := s.ignoredChatsMap[chatID]; !ok {
|
||||
return false
|
||||
}
|
||||
|
||||
delete(s.ignoredChatsMap, chatID)
|
||||
return true
|
||||
}
|
||||
|
||||
// IsChatIgnored checks the chat id against the ignore list
|
||||
func (s *Session) IsChatIgnored(chatID int64) bool {
|
||||
sessionsLock.Lock()
|
||||
defer sessionsLock.Unlock()
|
||||
|
||||
if s.ignoredChatsMap == nil {
|
||||
return false
|
||||
}
|
||||
|
||||
_, ok := s.ignoredChatsMap[chatID]
|
||||
return ok
|
||||
}
|
||||
|
||||
func fromBool(b bool) string {
|
||||
if b {
|
||||
return "true"
|
||||
|
|
|
|||
|
|
@ -48,7 +48,6 @@ func TestSessionToMap(t *testing.T) {
|
|||
Timezone: "klsf",
|
||||
RawMessages: true,
|
||||
OOBMode: true,
|
||||
Receipts: true,
|
||||
}
|
||||
m := session.ToMap()
|
||||
sample := map[string]string{
|
||||
|
|
@ -59,8 +58,6 @@ func TestSessionToMap(t *testing.T) {
|
|||
"oobmode": "true",
|
||||
"carbons": "false",
|
||||
"hideids": "false",
|
||||
"receipts": "true",
|
||||
"nativeedits": "false",
|
||||
}
|
||||
if !reflect.DeepEqual(m, sample) {
|
||||
t.Errorf("Map does not match the sample: %v", m)
|
||||
|
|
@ -88,31 +85,3 @@ func TestSessionSetAbsent(t *testing.T) {
|
|||
t.Error("There shouldn't come a donkey!")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSessionIgnore(t *testing.T) {
|
||||
session := Session{}
|
||||
if session.IsChatIgnored(3) {
|
||||
t.Error("Shouldn't be ignored yet")
|
||||
}
|
||||
if !session.IgnoreChat(3) {
|
||||
t.Error("Shouldn't have been ignored")
|
||||
}
|
||||
if session.IgnoreChat(3) {
|
||||
t.Error("Shouldn't ignore second time")
|
||||
}
|
||||
if !session.IsChatIgnored(3) {
|
||||
t.Error("Should be ignored already")
|
||||
}
|
||||
if session.IsChatIgnored(-145) {
|
||||
t.Error("Wrong chat is ignored")
|
||||
}
|
||||
if !session.UnignoreChat(3) {
|
||||
t.Error("Should successfully unignore")
|
||||
}
|
||||
if session.UnignoreChat(3) {
|
||||
t.Error("Should unignore second time")
|
||||
}
|
||||
if session.IsChatIgnored(3) {
|
||||
t.Error("Shouldn't be ignored already")
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,46 +0,0 @@
|
|||
FROM golang:1.19-bullseye AS base
|
||||
|
||||
RUN apt-get update
|
||||
RUN apt-get install -y libssl-dev cmake build-essential gperf libz-dev make git php
|
||||
|
||||
FROM base AS tdlib
|
||||
|
||||
ARG TD_COMMIT
|
||||
ARG MAKEOPTS
|
||||
RUN git clone https://github.com/tdlib/td /src/
|
||||
RUN git -C /src/ checkout "${TD_COMMIT}"
|
||||
RUN mkdir build
|
||||
WORKDIR /build/
|
||||
RUN cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/compiled/ /src/
|
||||
RUN cmake --build . --target prepare_cross_compiling ${MAKEOPTS}
|
||||
WORKDIR /src/
|
||||
RUN php SplitSource.php
|
||||
WORKDIR /build/
|
||||
RUN cmake --build . ${MAKEOPTS}
|
||||
RUN make install
|
||||
|
||||
FROM base AS cache
|
||||
ARG VERSION
|
||||
COPY --from=tdlib /compiled/ /usr/local/
|
||||
WORKDIR /src
|
||||
RUN go env -w GOCACHE=/go-cache
|
||||
RUN go env -w GOMODCACHE=/gomod-cache
|
||||
RUN --mount=type=cache,target=/gomod-cache \
|
||||
--mount=type=bind,source=./,target=/src \
|
||||
go mod download
|
||||
|
||||
FROM cache AS build
|
||||
ARG MAKEOPTS
|
||||
WORKDIR /src
|
||||
RUN --mount=type=bind,source=./,target=/src,rw \
|
||||
--mount=type=cache,target=/go-cache \
|
||||
--mount=type=cache,target=/gomod-cache \
|
||||
--mount=type=cache,destination=/src/release \
|
||||
make ${MAKEOPTS}
|
||||
|
||||
FROM build AS release
|
||||
RUN --mount=type=cache,destination=/src/release \
|
||||
cp /src/release/telegabber /
|
||||
|
||||
FROM scratch AS binaries
|
||||
COPY --from=release /telegabber /
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
FROM golang:1.19-bullseye AS base
|
||||
|
||||
RUN apt-get update
|
||||
RUN apt-get install -y libssl-dev cmake build-essential gperf libz-dev make git php
|
||||
|
||||
FROM base AS tdlib
|
||||
|
||||
ARG TD_COMMIT
|
||||
ARG MAKEOPTS
|
||||
RUN git clone https://github.com/tdlib/td /src/
|
||||
RUN git -C /src/ checkout "${TD_COMMIT}"
|
||||
RUN mkdir build
|
||||
WORKDIR /build/
|
||||
RUN cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/compiled/ /src/
|
||||
RUN cmake --build . --target prepare_cross_compiling ${MAKEOPTS}
|
||||
WORKDIR /src/
|
||||
RUN php SplitSource.php
|
||||
WORKDIR /build/
|
||||
RUN cmake --build . ${MAKEOPTS}
|
||||
RUN make install
|
||||
|
||||
FROM scratch AS binaries
|
||||
COPY --from=tdlib /compiled/ /
|
||||
|
|
@ -12,11 +12,10 @@ import (
|
|||
"dev.narayana.im/narayana/telegabber/xmpp"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
"github.com/zelenin/go-tdlib/client"
|
||||
goxmpp "gosrc.io/xmpp"
|
||||
)
|
||||
|
||||
var version string = "1.9.6"
|
||||
var version string = "1.6.1-dev"
|
||||
var commit string
|
||||
|
||||
var sm *goxmpp.StreamManager
|
||||
|
|
@ -61,9 +60,6 @@ func main() {
|
|||
log.Fatal(err)
|
||||
}
|
||||
|
||||
client.SetLogVerbosityLevel(&client.SetLogVerbosityLevelRequest{
|
||||
NewVerbosityLevel: stringToTdlibLogConstant(config.Telegram.Loglevel),
|
||||
})
|
||||
SetLogrusLevel(config.XMPP.Loglevel)
|
||||
|
||||
log.Infof("Starting telegabber version %v", version)
|
||||
|
|
@ -93,25 +89,6 @@ func main() {
|
|||
}
|
||||
}
|
||||
|
||||
var tdlibLogConstants = map[string]int32{
|
||||
":fatal": 0,
|
||||
":error": 1,
|
||||
":warn": 2,
|
||||
":info": 3,
|
||||
":debug": 4,
|
||||
":verbose": 5,
|
||||
":all": 1023,
|
||||
}
|
||||
|
||||
func stringToTdlibLogConstant(c string) int32 {
|
||||
level, ok := tdlibLogConstants[c]
|
||||
if !ok {
|
||||
level = 0
|
||||
}
|
||||
|
||||
return level
|
||||
}
|
||||
|
||||
func exit() {
|
||||
xmpp.Close(component)
|
||||
close(cleanupDone)
|
||||
|
|
|
|||
|
|
@ -1,19 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestTdlibLogInfo(t *testing.T) {
|
||||
tdlibConstant := stringToTdlibLogConstant(":info")
|
||||
if tdlibConstant != 3 {
|
||||
t.Errorf("Wrong TDlib constant for info")
|
||||
}
|
||||
}
|
||||
|
||||
func TestTdlibLogInvalid(t *testing.T) {
|
||||
tdlibConstant := stringToTdlibLogConstant("ziz")
|
||||
if tdlibConstant != 0 {
|
||||
t.Errorf("Unknown strings should return fatal loglevel")
|
||||
}
|
||||
}
|
||||
10
telegram/cache/cache.go
vendored
10
telegram/cache/cache.go
vendored
|
|
@ -133,13 +133,3 @@ func (cache *Cache) SetStatus(id int64, show string, status string) {
|
|||
Description: status,
|
||||
}
|
||||
}
|
||||
|
||||
// Destruct splits a cached status into show, description and type
|
||||
func (status *Status) Destruct() (show, description, typ string) {
|
||||
show, description = status.XMPP, status.Description
|
||||
if show == "unavailable" {
|
||||
typ = show
|
||||
show = ""
|
||||
}
|
||||
return
|
||||
}
|
||||
|
|
|
|||
|
|
@ -2,7 +2,6 @@ package telegram
|
|||
|
||||
import (
|
||||
"github.com/pkg/errors"
|
||||
"hash/maphash"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"sync"
|
||||
|
|
@ -16,6 +15,25 @@ import (
|
|||
"gosrc.io/xmpp"
|
||||
)
|
||||
|
||||
var logConstants = map[string]int32{
|
||||
":fatal": 0,
|
||||
":error": 1,
|
||||
":warn": 2,
|
||||
":info": 3,
|
||||
":debug": 4,
|
||||
":verbose": 5,
|
||||
":all": 1023,
|
||||
}
|
||||
|
||||
func stringToLogConstant(c string) int32 {
|
||||
level, ok := logConstants[c]
|
||||
if !ok {
|
||||
level = 0
|
||||
}
|
||||
|
||||
return level
|
||||
}
|
||||
|
||||
// DelayedStatus describes an online status expiring on timeout
|
||||
type DelayedStatus struct {
|
||||
TimestampOnline int64
|
||||
|
|
@ -26,7 +44,7 @@ type DelayedStatus struct {
|
|||
type Client struct {
|
||||
client *client.Client
|
||||
authorizer *clientAuthorizer
|
||||
parameters *client.SetTdlibParametersRequest
|
||||
parameters *client.TdlibParameters
|
||||
options []client.Option
|
||||
me *client.User
|
||||
|
||||
|
|
@ -38,37 +56,26 @@ type Client struct {
|
|||
cache *cache.Cache
|
||||
online bool
|
||||
|
||||
outbox map[string]string
|
||||
editOutbox map[string]string
|
||||
|
||||
DelayedStatuses map[int64]*DelayedStatus
|
||||
DelayedStatusesLock sync.Mutex
|
||||
|
||||
lastMsgHashes map[int64]uint64
|
||||
lastMsgIds map[int64]string
|
||||
msgHashSeed maphash.Seed
|
||||
|
||||
locks clientLocks
|
||||
SendMessageLock sync.Mutex
|
||||
locks clientLocks
|
||||
}
|
||||
|
||||
type clientLocks struct {
|
||||
authorizationReady sync.Mutex
|
||||
chatMessageLocks map[int64]*sync.Mutex
|
||||
resourcesLock sync.Mutex
|
||||
outboxLock sync.Mutex
|
||||
editOutboxLock sync.Mutex
|
||||
lastMsgHashesLock sync.Mutex
|
||||
lastMsgIdsLock sync.RWMutex
|
||||
|
||||
authorizerReadLock sync.Mutex
|
||||
authorizerWriteLock sync.Mutex
|
||||
}
|
||||
|
||||
// NewClient instantiates a Telegram App
|
||||
func NewClient(conf config.TelegramConfig, jid string, component *xmpp.Component, session *persistence.Session) (*Client, error) {
|
||||
var options []client.Option
|
||||
|
||||
options = append(options, client.WithLogVerbosity(&client.SetLogVerbosityLevelRequest{
|
||||
NewVerbosityLevel: stringToLogConstant(conf.Loglevel),
|
||||
}))
|
||||
|
||||
if conf.Tdlib.Client.CatchTimeout != 0 {
|
||||
options = append(options, client.WithCatchTimeout(
|
||||
time.Duration(conf.Tdlib.Client.CatchTimeout)*time.Second,
|
||||
|
|
@ -85,7 +92,7 @@ func NewClient(conf config.TelegramConfig, jid string, component *xmpp.Component
|
|||
datadir = "./sessions/" // ye olde defaute
|
||||
}
|
||||
|
||||
parameters := client.SetTdlibParametersRequest{
|
||||
parameters := client.TdlibParameters{
|
||||
UseTestDc: false,
|
||||
|
||||
DatabaseDirectory: filepath.Join(datadir, jid),
|
||||
|
|
@ -116,13 +123,8 @@ func NewClient(conf config.TelegramConfig, jid string, component *xmpp.Component
|
|||
resources: make(map[string]bool),
|
||||
content: &conf.Content,
|
||||
cache: cache.NewCache(),
|
||||
outbox: make(map[string]string),
|
||||
editOutbox: make(map[string]string),
|
||||
options: options,
|
||||
DelayedStatuses: make(map[int64]*DelayedStatus),
|
||||
lastMsgHashes: make(map[int64]uint64),
|
||||
lastMsgIds: make(map[int64]string),
|
||||
msgHashSeed: maphash.MakeSeed(),
|
||||
locks: clientLocks{
|
||||
chatMessageLocks: make(map[int64]*sync.Mutex),
|
||||
},
|
||||
|
|
|
|||
19
telegram/client_test.go
Normal file
19
telegram/client_test.go
Normal file
|
|
@ -0,0 +1,19 @@
|
|||
package telegram
|
||||
|
||||
import (
|
||||
"testing"
|
||||
)
|
||||
|
||||
func TestLogInfo(t *testing.T) {
|
||||
tdlibConstant := stringToLogConstant(":info")
|
||||
if tdlibConstant != 3 {
|
||||
t.Errorf("Wrong TDlib constant for info")
|
||||
}
|
||||
}
|
||||
|
||||
func TestLogInvalid(t *testing.T) {
|
||||
tdlibConstant := stringToLogConstant("ziz")
|
||||
if tdlibConstant != 0 {
|
||||
t.Errorf("Unknown strings should return fatal loglevel")
|
||||
}
|
||||
}
|
||||
|
|
@ -15,11 +15,11 @@ import (
|
|||
)
|
||||
|
||||
const notEnoughArguments string = "Not enough arguments"
|
||||
const TelegramNotInitialized string = "Telegram connection is not initialized yet"
|
||||
const TelegramAuthDone string = "Authorization is done already"
|
||||
const telegramNotInitialized string = "Telegram connection is not initialized yet"
|
||||
const notOnline string = "Not online"
|
||||
|
||||
var permissionsAdmin = client.ChatAdministratorRights{
|
||||
var permissionsAdmin = client.ChatMemberStatusAdministrator{
|
||||
CanBeEdited: true,
|
||||
CanChangeInfo: true,
|
||||
CanPostMessages: true,
|
||||
CanEditMessages: true,
|
||||
|
|
@ -30,20 +30,14 @@ var permissionsAdmin = client.ChatAdministratorRights{
|
|||
CanPromoteMembers: false,
|
||||
}
|
||||
var permissionsMember = client.ChatPermissions{
|
||||
CanSendBasicMessages: true,
|
||||
CanSendAudios: true,
|
||||
CanSendDocuments: true,
|
||||
CanSendPhotos: true,
|
||||
CanSendVideos: true,
|
||||
CanSendVideoNotes: true,
|
||||
CanSendVoiceNotes: true,
|
||||
CanSendMessages: true,
|
||||
CanSendMediaMessages: true,
|
||||
CanSendPolls: true,
|
||||
CanSendOtherMessages: true,
|
||||
CanAddWebPagePreviews: true,
|
||||
CanChangeInfo: true,
|
||||
CanInviteUsers: true,
|
||||
CanPinMessages: true,
|
||||
CanManageTopics: true,
|
||||
}
|
||||
var permissionsReadonly = client.ChatPermissions{}
|
||||
|
||||
|
|
@ -85,8 +79,8 @@ var chatCommands = map[string]command{
|
|||
"invite": command{"id or @username", "add user to current chat"},
|
||||
"link": command{"", "get invite link for current chat"},
|
||||
"kick": command{"id or @username", "remove user to current chat"},
|
||||
"mute": command{"[id or @username] [hours]", "mute the whole chat or a user in current chat"},
|
||||
"unmute": command{"[id or @username]", "unmute the whole chat or a user in the current chat"},
|
||||
"mute": command{"id or @username [hours]", "mute user in current chat"},
|
||||
"unmute": command{"id or @username", "unrestrict user from current chat"},
|
||||
"ban": command{"id or @username [hours]", "restrict @username from current chat for [hours] or forever"},
|
||||
"unban": command{"id or @username", "unbans @username in current chat (and devotes from admins)"},
|
||||
"promote": command{"id or @username [title]", "promote user to admin in current chat"},
|
||||
|
|
@ -185,14 +179,18 @@ func keyValueString(key, value string) string {
|
|||
}
|
||||
|
||||
func (c *Client) unsubscribe(chatID int64) error {
|
||||
args := gateway.SimplePresence(chatID, "unsubscribed")
|
||||
return c.sendPresence(args...)
|
||||
return gateway.SendPresence(
|
||||
c.xmpp,
|
||||
c.jid,
|
||||
gateway.SPFrom(strconv.FormatInt(chatID, 10)),
|
||||
gateway.SPType("unsubscribed"),
|
||||
)
|
||||
}
|
||||
|
||||
func (c *Client) sendMessagesReverse(chatID int64, messages []*client.Message) {
|
||||
for i := len(messages) - 1; i >= 0; i-- {
|
||||
message := messages[i]
|
||||
reply, _ := c.getMessageReply(message, false, true)
|
||||
reply, _ := c.getMessageReply(message)
|
||||
|
||||
gateway.SendMessage(
|
||||
c.jid,
|
||||
|
|
@ -201,9 +199,8 @@ func (c *Client) sendMessagesReverse(chatID int64, messages []*client.Message) {
|
|||
strconv.FormatInt(message.Id, 10),
|
||||
c.xmpp,
|
||||
reply,
|
||||
false,
|
||||
"",
|
||||
false,
|
||||
false,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
|
@ -243,35 +240,40 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) string
|
|||
}
|
||||
|
||||
if cmd == "login" {
|
||||
err := c.TryLogin(resource, args[0])
|
||||
if err != nil {
|
||||
return err.Error()
|
||||
wasSessionLoginEmpty := c.Session.Login == ""
|
||||
c.Session.Login = args[0]
|
||||
|
||||
if wasSessionLoginEmpty && c.authorizer == nil {
|
||||
go func() {
|
||||
err := c.Connect(resource)
|
||||
if err != nil {
|
||||
log.Error(errors.Wrap(err, "TDlib connection failure"))
|
||||
}
|
||||
}()
|
||||
// a quirk for authorizer to become ready. If it's still not,
|
||||
// nothing bad: the command just needs to be resent again
|
||||
time.Sleep(1e5)
|
||||
}
|
||||
}
|
||||
|
||||
c.locks.authorizerWriteLock.Lock()
|
||||
defer c.locks.authorizerWriteLock.Unlock()
|
||||
if c.authorizer == nil {
|
||||
return telegramNotInitialized
|
||||
}
|
||||
|
||||
if c.authorizer.isClosed {
|
||||
return "Authorization is done already"
|
||||
}
|
||||
|
||||
switch cmd {
|
||||
// sign in
|
||||
case "login":
|
||||
c.authorizer.PhoneNumber <- args[0]
|
||||
} else {
|
||||
c.locks.authorizerWriteLock.Lock()
|
||||
defer c.locks.authorizerWriteLock.Unlock()
|
||||
|
||||
if c.authorizer == nil {
|
||||
return TelegramNotInitialized
|
||||
}
|
||||
|
||||
if c.authorizer.isClosed {
|
||||
return TelegramAuthDone
|
||||
}
|
||||
|
||||
switch cmd {
|
||||
// check auth code
|
||||
case "code":
|
||||
c.authorizer.Code <- args[0]
|
||||
// check auth password
|
||||
case "password":
|
||||
c.authorizer.Password <- args[0]
|
||||
}
|
||||
// check auth code
|
||||
case "code":
|
||||
c.authorizer.Code <- args[0]
|
||||
// check auth password
|
||||
case "password":
|
||||
c.authorizer.Password <- args[0]
|
||||
}
|
||||
// sign out
|
||||
case "logout":
|
||||
|
|
@ -279,15 +281,16 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) string
|
|||
return notOnline
|
||||
}
|
||||
|
||||
_, err := c.client.LogOut()
|
||||
if err != nil {
|
||||
return errors.Wrap(err, "Logout error").Error()
|
||||
}
|
||||
|
||||
for _, id := range c.cache.ChatsKeys() {
|
||||
c.unsubscribe(id)
|
||||
}
|
||||
|
||||
_, err := c.client.LogOut()
|
||||
if err != nil {
|
||||
c.forceClose()
|
||||
return errors.Wrap(err, "Logout error").Error()
|
||||
}
|
||||
|
||||
c.Session.Login = ""
|
||||
// cancel auth
|
||||
case "cancelauth":
|
||||
|
|
@ -327,13 +330,10 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) string
|
|||
lastname = rawCmdArguments(cmdline, 1)
|
||||
}
|
||||
|
||||
c.locks.authorizerWriteLock.Lock()
|
||||
if c.authorizer != nil && !c.authorizer.isClosed {
|
||||
c.authorizer.FirstName <- firstname
|
||||
c.authorizer.LastName <- lastname
|
||||
c.locks.authorizerWriteLock.Unlock()
|
||||
} else {
|
||||
c.locks.authorizerWriteLock.Unlock()
|
||||
if !c.Online() {
|
||||
return notOnline
|
||||
}
|
||||
|
|
@ -380,8 +380,7 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) string
|
|||
}
|
||||
case "config":
|
||||
if len(args) > 1 {
|
||||
var msg string
|
||||
if gateway.MessageOutgoingPermissionVersion == 0 && args[0] == "carbons" && args[1] == "true" {
|
||||
if !gateway.MessageOutgoingPermission && args[0] == "carbons" && args[1] == "true" {
|
||||
return "The server did not allow to enable carbons"
|
||||
}
|
||||
|
||||
|
|
@ -391,7 +390,7 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) string
|
|||
}
|
||||
gateway.DirtySessions = true
|
||||
|
||||
return fmt.Sprintf("%s%s set to %s", msg, args[0], value)
|
||||
return fmt.Sprintf("%s set to %s", args[0], value)
|
||||
} else if len(args) > 0 {
|
||||
value, err := c.Session.Get(args[0])
|
||||
if err != nil {
|
||||
|
|
@ -420,7 +419,7 @@ func (c *Client) ProcessTransportCommand(cmdline string, resource string) string
|
|||
text := rawCmdArguments(cmdline, 1)
|
||||
_, err = c.client.ReportChat(&client.ReportChatRequest{
|
||||
ChatId: contact.Id,
|
||||
Reason: &client.ReportReasonCustom{},
|
||||
Reason: &client.ChatReportReasonCustom{},
|
||||
Text: text,
|
||||
})
|
||||
if err != nil {
|
||||
|
|
@ -515,14 +514,11 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool)
|
|||
content := c.PrepareOutgoingMessageContent(rawCmdArguments(cmdline, 0))
|
||||
|
||||
if content != nil {
|
||||
_, err = c.client.EditMessageText(&client.EditMessageTextRequest{
|
||||
c.client.EditMessageText(&client.EditMessageTextRequest{
|
||||
ChatId: chatID,
|
||||
MessageId: message.Id,
|
||||
InputMessageContent: content,
|
||||
})
|
||||
if err != nil {
|
||||
return "Message editing error", true
|
||||
}
|
||||
} else {
|
||||
return "Message processing error", true
|
||||
}
|
||||
|
|
@ -668,7 +664,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool)
|
|||
entries := []string{
|
||||
keyValueString("Chat title", info.Fn),
|
||||
keyValueString("Photo", link),
|
||||
keyValueString("Usernames", c.usernamesToString(info.Nicknames)),
|
||||
keyValueString("Username", info.Nickname),
|
||||
keyValueString("Full name", info.Given+" "+info.Family),
|
||||
keyValueString("Phone number", info.Tel),
|
||||
}
|
||||
|
|
@ -708,18 +704,18 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool)
|
|||
}
|
||||
// blacklists current user
|
||||
case "block":
|
||||
_, err := c.client.SetMessageSenderBlockList(&client.SetMessageSenderBlockListRequest{
|
||||
_, err := c.client.ToggleMessageSenderIsBlocked(&client.ToggleMessageSenderIsBlockedRequest{
|
||||
SenderId: &client.MessageSenderUser{UserId: chatID},
|
||||
BlockList: &client.BlockListMain{},
|
||||
IsBlocked: true,
|
||||
})
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
// unblacklists current user
|
||||
case "unblock":
|
||||
_, err := c.client.SetMessageSenderBlockList(&client.SetMessageSenderBlockListRequest{
|
||||
_, err := c.client.ToggleMessageSenderIsBlocked(&client.ToggleMessageSenderIsBlockedRequest{
|
||||
SenderId: &client.MessageSenderUser{UserId: chatID},
|
||||
BlockList: nil,
|
||||
IsBlocked: false,
|
||||
})
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
|
|
@ -771,65 +767,59 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool)
|
|||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
// mute [@username [n hours]]
|
||||
// mute @username [n hours]
|
||||
case "mute":
|
||||
if len(args) > 0 {
|
||||
contact, _, err := c.GetContactByUsername(args[0])
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
|
||||
var hours int64
|
||||
if len(args) > 1 {
|
||||
hours, err = strconv.ParseInt(args[1], 10, 32)
|
||||
if err != nil {
|
||||
return "Invalid number of hours", true
|
||||
}
|
||||
}
|
||||
|
||||
_, err = c.client.SetChatMemberStatus(&client.SetChatMemberStatusRequest{
|
||||
ChatId: chatID,
|
||||
MemberId: &client.MessageSenderUser{UserId: contact.Id},
|
||||
Status: &client.ChatMemberStatusRestricted{
|
||||
IsMember: true,
|
||||
RestrictedUntilDate: c.formatBantime(hours),
|
||||
Permissions: &permissionsReadonly,
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
} else {
|
||||
if !c.Session.IgnoreChat(chatID) {
|
||||
return "Chat is already ignored", true
|
||||
}
|
||||
gateway.DirtySessions = true
|
||||
if len(args) < 1 {
|
||||
return notEnoughArguments, true
|
||||
}
|
||||
// unmute [@username]
|
||||
case "unmute":
|
||||
if len(args) > 0 {
|
||||
contact, _, err := c.GetContactByUsername(args[0])
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
|
||||
_, err = c.client.SetChatMemberStatus(&client.SetChatMemberStatusRequest{
|
||||
ChatId: chatID,
|
||||
MemberId: &client.MessageSenderUser{UserId: contact.Id},
|
||||
Status: &client.ChatMemberStatusRestricted{
|
||||
IsMember: true,
|
||||
RestrictedUntilDate: 0,
|
||||
Permissions: &permissionsMember,
|
||||
},
|
||||
})
|
||||
contact, _, err := c.GetContactByUsername(args[0])
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
|
||||
var hours int64
|
||||
if len(args) > 1 {
|
||||
hours, err = strconv.ParseInt(args[1], 10, 32)
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
return "Invalid number of hours", true
|
||||
}
|
||||
} else {
|
||||
if !c.Session.UnignoreChat(chatID) {
|
||||
return "Chat wasn't ignored", true
|
||||
}
|
||||
gateway.DirtySessions = true
|
||||
}
|
||||
|
||||
_, err = c.client.SetChatMemberStatus(&client.SetChatMemberStatusRequest{
|
||||
ChatId: chatID,
|
||||
MemberId: &client.MessageSenderUser{UserId: contact.Id},
|
||||
Status: &client.ChatMemberStatusRestricted{
|
||||
IsMember: true,
|
||||
RestrictedUntilDate: c.formatBantime(hours),
|
||||
Permissions: &permissionsReadonly,
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
// unmute @username
|
||||
case "unmute":
|
||||
if len(args) < 1 {
|
||||
return notEnoughArguments, true
|
||||
}
|
||||
|
||||
contact, _, err := c.GetContactByUsername(args[0])
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
|
||||
_, err = c.client.SetChatMemberStatus(&client.SetChatMemberStatusRequest{
|
||||
ChatId: chatID,
|
||||
MemberId: &client.MessageSenderUser{UserId: contact.Id},
|
||||
Status: &client.ChatMemberStatusRestricted{
|
||||
IsMember: true,
|
||||
RestrictedUntilDate: 0,
|
||||
Permissions: &permissionsMember,
|
||||
},
|
||||
})
|
||||
if err != nil {
|
||||
return err.Error(), true
|
||||
}
|
||||
// ban @username from current chat [for N hours]
|
||||
case "ban":
|
||||
|
|
@ -891,10 +881,7 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool)
|
|||
}
|
||||
|
||||
// clone the permissions
|
||||
status := client.ChatMemberStatusAdministrator{
|
||||
CanBeEdited: true,
|
||||
Rights: &permissionsAdmin,
|
||||
}
|
||||
status := permissionsAdmin
|
||||
|
||||
if len(args) > 1 {
|
||||
status.CustomTitle = args[1]
|
||||
|
|
@ -944,9 +931,9 @@ func (c *Client) ProcessChatCommand(chatID int64, cmdline string) (string, bool)
|
|||
return "Invalid TTL", true
|
||||
}
|
||||
}
|
||||
_, err = c.client.SetChatMessageAutoDeleteTime(&client.SetChatMessageAutoDeleteTimeRequest{
|
||||
ChatId: chatID,
|
||||
MessageAutoDeleteTime: int32(ttl),
|
||||
_, err = c.client.SetChatMessageTtl(&client.SetChatMessageTtlRequest{
|
||||
ChatId: chatID,
|
||||
Ttl: int32(ttl),
|
||||
})
|
||||
|
||||
if err != nil {
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@ package telegram
|
|||
|
||||
import (
|
||||
"github.com/pkg/errors"
|
||||
"time"
|
||||
"strconv"
|
||||
|
||||
"dev.narayana.im/narayana/telegabber/xmpp/gateway"
|
||||
|
||||
|
|
@ -13,7 +13,7 @@ import (
|
|||
const chatsLimit int32 = 999
|
||||
|
||||
type clientAuthorizer struct {
|
||||
TdlibParameters chan *client.SetTdlibParametersRequest
|
||||
TdlibParameters chan *client.TdlibParameters
|
||||
PhoneNumber chan string
|
||||
Code chan string
|
||||
State chan client.AuthorizationState
|
||||
|
|
@ -31,7 +31,13 @@ func (stateHandler *clientAuthorizer) Handle(c *client.Client, state client.Auth
|
|||
|
||||
switch state.AuthorizationStateType() {
|
||||
case client.TypeAuthorizationStateWaitTdlibParameters:
|
||||
_, err := c.SetTdlibParameters(<-stateHandler.TdlibParameters)
|
||||
_, err := c.SetTdlibParameters(&client.SetTdlibParametersRequest{
|
||||
Parameters: <-stateHandler.TdlibParameters,
|
||||
})
|
||||
return err
|
||||
|
||||
case client.TypeAuthorizationStateWaitEncryptionKey:
|
||||
_, err := c.CheckDatabaseEncryptionKey(&client.CheckDatabaseEncryptionKeyRequest{})
|
||||
return err
|
||||
|
||||
case client.TypeAuthorizationStateWaitPhoneNumber:
|
||||
|
|
@ -68,10 +74,10 @@ func (stateHandler *clientAuthorizer) Handle(c *client.Client, state client.Auth
|
|||
return nil
|
||||
|
||||
case client.TypeAuthorizationStateLoggingOut:
|
||||
return nil
|
||||
return client.ErrNotSupportedAuthorizationState
|
||||
|
||||
case client.TypeAuthorizationStateClosing:
|
||||
return nil
|
||||
return client.ErrNotSupportedAuthorizationState
|
||||
|
||||
case client.TypeAuthorizationStateClosed:
|
||||
return client.ErrNotSupportedAuthorizationState
|
||||
|
|
@ -109,9 +115,8 @@ func (c *Client) Connect(resource string) error {
|
|||
|
||||
log.Warn("Connecting to Telegram network...")
|
||||
|
||||
c.locks.authorizerWriteLock.Lock()
|
||||
c.authorizer = &clientAuthorizer{
|
||||
TdlibParameters: make(chan *client.SetTdlibParametersRequest, 1),
|
||||
TdlibParameters: make(chan *client.TdlibParameters, 1),
|
||||
PhoneNumber: make(chan string, 1),
|
||||
Code: make(chan string, 1),
|
||||
State: make(chan client.AuthorizationState, 10),
|
||||
|
|
@ -121,10 +126,8 @@ func (c *Client) Connect(resource string) error {
|
|||
}
|
||||
|
||||
go c.interactor()
|
||||
log.Warn("Interactor launched")
|
||||
|
||||
c.authorizer.TdlibParameters <- c.parameters
|
||||
c.locks.authorizerWriteLock.Unlock()
|
||||
|
||||
tdlibClient, err := client.NewClient(c.authorizer, c.options...)
|
||||
if err != nil {
|
||||
|
|
@ -157,55 +160,14 @@ func (c *Client) Connect(resource string) error {
|
|||
log.Errorf("Could not retrieve chats: %v", err)
|
||||
}
|
||||
|
||||
gateway.SubscribeToTransport(c.xmpp, c.jid)
|
||||
c.sendPresence(gateway.SPStatus("Logged in as: " + c.Session.Login))
|
||||
gateway.SendPresence(c.xmpp, c.jid, gateway.SPType("subscribe"))
|
||||
gateway.SendPresence(c.xmpp, c.jid, gateway.SPType("subscribed"))
|
||||
gateway.SendPresence(c.xmpp, c.jid, gateway.SPStatus("Logged in as: "+c.Session.Login))
|
||||
}()
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Client) TryLogin(resource string, login string) error {
|
||||
wasSessionLoginEmpty := c.Session.Login == ""
|
||||
c.Session.Login = login
|
||||
|
||||
if wasSessionLoginEmpty && c.authorizer == nil {
|
||||
go func() {
|
||||
err := c.Connect(resource)
|
||||
if err != nil {
|
||||
log.Error(errors.Wrap(err, "TDlib connection failure"))
|
||||
}
|
||||
}()
|
||||
// a quirk for authorizer to become ready. If it's still not,
|
||||
// nothing bad: just re-login again
|
||||
time.Sleep(1e5)
|
||||
}
|
||||
|
||||
c.locks.authorizerWriteLock.Lock()
|
||||
defer c.locks.authorizerWriteLock.Unlock()
|
||||
|
||||
if c.authorizer == nil {
|
||||
return errors.New(TelegramNotInitialized)
|
||||
}
|
||||
|
||||
if c.authorizer.isClosed {
|
||||
return errors.New(TelegramAuthDone)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func (c *Client) SetPhoneNumber(login string) error {
|
||||
c.locks.authorizerWriteLock.Lock()
|
||||
defer c.locks.authorizerWriteLock.Unlock()
|
||||
|
||||
if c.authorizer == nil || c.authorizer.isClosed {
|
||||
return errors.New("Authorization not needed")
|
||||
}
|
||||
|
||||
c.authorizer.PhoneNumber <- login
|
||||
return nil
|
||||
}
|
||||
|
||||
// Disconnect drops TDlib connection and
|
||||
// returns the flag indicating if disconnecting is permitted
|
||||
func (c *Client) Disconnect(resource string, quit bool) bool {
|
||||
|
|
@ -227,8 +189,12 @@ func (c *Client) Disconnect(resource string, quit bool) bool {
|
|||
|
||||
// we're offline (unsubscribe if logout)
|
||||
for _, id := range c.cache.ChatsKeys() {
|
||||
args := gateway.SimplePresence(id, "unavailable")
|
||||
c.sendPresence(args...)
|
||||
gateway.SendPresence(
|
||||
c.xmpp,
|
||||
c.jid,
|
||||
gateway.SPFrom(strconv.FormatInt(id, 10)),
|
||||
gateway.SPType("unavailable"),
|
||||
)
|
||||
}
|
||||
|
||||
c.close()
|
||||
|
|
@ -238,16 +204,9 @@ func (c *Client) Disconnect(resource string, quit bool) bool {
|
|||
|
||||
func (c *Client) interactor() {
|
||||
for {
|
||||
c.locks.authorizerReadLock.Lock()
|
||||
if c.authorizer == nil {
|
||||
log.Warn("Authorizer is lost, halting the interactor")
|
||||
c.locks.authorizerReadLock.Unlock()
|
||||
return
|
||||
}
|
||||
state, ok := <-c.authorizer.State
|
||||
if !ok {
|
||||
log.Warn("Interactor is disconnected")
|
||||
c.locks.authorizerReadLock.Unlock()
|
||||
return
|
||||
}
|
||||
|
||||
|
|
@ -277,27 +236,18 @@ func (c *Client) interactor() {
|
|||
log.Warn("Waiting for 2FA password...")
|
||||
gateway.SendServiceMessage(c.jid, "Please, enter 2FA passphrase via /password 12345", c.xmpp)
|
||||
}
|
||||
c.locks.authorizerReadLock.Unlock()
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) forceClose() {
|
||||
c.locks.authorizerReadLock.Lock()
|
||||
c.locks.authorizerWriteLock.Lock()
|
||||
defer c.locks.authorizerReadLock.Unlock()
|
||||
defer c.locks.authorizerWriteLock.Unlock()
|
||||
|
||||
c.online = false
|
||||
c.authorizer = nil
|
||||
}
|
||||
|
||||
func (c *Client) close() {
|
||||
c.locks.authorizerWriteLock.Lock()
|
||||
if c.authorizer != nil && !c.authorizer.isClosed {
|
||||
c.authorizer.Close()
|
||||
}
|
||||
c.locks.authorizerWriteLock.Unlock()
|
||||
|
||||
if c.client != nil {
|
||||
_, err := c.client.Close()
|
||||
if err != nil {
|
||||
|
|
|
|||
|
|
@ -8,31 +8,15 @@ import (
|
|||
"github.com/zelenin/go-tdlib/client"
|
||||
)
|
||||
|
||||
type insertionType int
|
||||
|
||||
const (
|
||||
insertionOpening insertionType = iota
|
||||
insertionClosing
|
||||
insertionUnpaired
|
||||
)
|
||||
|
||||
type MarkupModeType int
|
||||
|
||||
const (
|
||||
MarkupModeXEP0393 MarkupModeType = iota
|
||||
MarkupModeMarkdown
|
||||
)
|
||||
|
||||
// insertion is a piece of text in given position
|
||||
type insertion struct {
|
||||
// Insertion is a piece of text in given position
|
||||
type Insertion struct {
|
||||
Offset int32
|
||||
Runes []rune
|
||||
Type insertionType
|
||||
}
|
||||
|
||||
// insertionStack contains the sequence of insertions
|
||||
// InsertionStack contains the sequence of insertions
|
||||
// from the start or from the end
|
||||
type insertionStack []*insertion
|
||||
type InsertionStack []*Insertion
|
||||
|
||||
var boldRunesMarkdown = []rune("**")
|
||||
var boldRunesXEP0393 = []rune("*")
|
||||
|
|
@ -40,18 +24,13 @@ var italicRunes = []rune("_")
|
|||
var strikeRunesMarkdown = []rune("~~")
|
||||
var strikeRunesXEP0393 = []rune("~")
|
||||
var codeRunes = []rune("`")
|
||||
var preRunesStart = []rune("```\n")
|
||||
var preRunesEnd = []rune("\n```")
|
||||
var quoteRunes = []rune("> ")
|
||||
var newlineRunes = []rune("\n")
|
||||
var doubleNewlineRunes = []rune("\n\n")
|
||||
var newlineCode = rune(0x0000000a)
|
||||
var bmpCeil = rune(0x0000ffff)
|
||||
var preRuneStart = []rune("```\n")
|
||||
var preRuneEnd = []rune("\n```")
|
||||
|
||||
// rebalance pumps all the values until the given offset to current stack (growing
|
||||
// from start) from given stack (growing from end); should be called
|
||||
// before any insertions to the current stack at the given offset
|
||||
func (s insertionStack) rebalance(s2 insertionStack, offset int32) (insertionStack, insertionStack) {
|
||||
func (s InsertionStack) rebalance(s2 InsertionStack, offset int32) (InsertionStack, InsertionStack) {
|
||||
for len(s2) > 0 && s2[len(s2)-1].Offset <= offset {
|
||||
s = append(s, s2[len(s2)-1])
|
||||
s2 = s2[:len(s2)-1]
|
||||
|
|
@ -62,10 +41,10 @@ func (s insertionStack) rebalance(s2 insertionStack, offset int32) (insertionSta
|
|||
|
||||
// NewIterator is a second order function that sequentially scans and returns
|
||||
// stack elements; starts returning nil when elements are ended
|
||||
func (s insertionStack) NewIterator() func() *insertion {
|
||||
func (s InsertionStack) NewIterator() func() *Insertion {
|
||||
i := -1
|
||||
|
||||
return func() *insertion {
|
||||
return func() *Insertion {
|
||||
i++
|
||||
if i < len(s) {
|
||||
return s[i]
|
||||
|
|
@ -141,10 +120,21 @@ func MergeAdjacentEntities(entities []*client.TextEntity) []*client.TextEntity {
|
|||
}
|
||||
|
||||
// ClaspDirectives to the following span as required by XEP-0393
|
||||
func ClaspDirectives(doubledRunes []rune, entities []*client.TextEntity) []*client.TextEntity {
|
||||
func ClaspDirectives(text string, entities []*client.TextEntity) []*client.TextEntity {
|
||||
alignedEntities := make([]*client.TextEntity, len(entities))
|
||||
copy(alignedEntities, entities)
|
||||
|
||||
// transform the source text into a form with uniform runes and code points,
|
||||
// by duplicating the Basic Multilingual Plane
|
||||
doubledRunes := make([]rune, 0, len(text)*2)
|
||||
|
||||
for _, cp := range text {
|
||||
if cp > 0x0000ffff {
|
||||
doubledRunes = append(doubledRunes, cp, cp)
|
||||
} else {
|
||||
doubledRunes = append(doubledRunes, cp)
|
||||
}
|
||||
}
|
||||
for i, entity := range alignedEntities {
|
||||
var dirty bool
|
||||
endOffset := entity.Offset + entity.Length
|
||||
|
|
@ -177,89 +167,18 @@ func ClaspDirectives(doubledRunes []rune, entities []*client.TextEntity) []*clie
|
|||
return alignedEntities
|
||||
}
|
||||
|
||||
func markupBraces(entity *client.TextEntity, lbrace, rbrace []rune) []*insertion {
|
||||
return []*insertion{
|
||||
&insertion{
|
||||
func markupBraces(entity *client.TextEntity, lbrace, rbrace []rune) (*Insertion, *Insertion) {
|
||||
return &Insertion{
|
||||
Offset: entity.Offset,
|
||||
Runes: lbrace,
|
||||
Type: insertionOpening,
|
||||
},
|
||||
&insertion{
|
||||
}, &Insertion{
|
||||
Offset: entity.Offset + entity.Length,
|
||||
Runes: rbrace,
|
||||
Type: insertionClosing,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func quotePrependNewlines(entity *client.TextEntity, doubledRunes []rune, markupMode MarkupModeType) []*insertion {
|
||||
if len(doubledRunes) == 0 {
|
||||
return []*insertion{}
|
||||
}
|
||||
|
||||
startRunes := []rune("\n> ")
|
||||
if entity.Offset == 0 || doubledRunes[entity.Offset-1] == newlineCode {
|
||||
startRunes = quoteRunes
|
||||
}
|
||||
insertions := []*insertion{
|
||||
&insertion{
|
||||
Offset: entity.Offset,
|
||||
Runes: startRunes,
|
||||
Type: insertionUnpaired,
|
||||
},
|
||||
}
|
||||
|
||||
entityEnd := entity.Offset + entity.Length
|
||||
entityEndInt := int(entityEnd)
|
||||
|
||||
var wasNewline bool
|
||||
// last newline is omitted, there's no need to put quote mark after the quote
|
||||
for i := entity.Offset; i < entityEnd-1; i++ {
|
||||
isNewline := doubledRunes[i] == newlineCode
|
||||
if (isNewline && markupMode == MarkupModeXEP0393) || (wasNewline && isNewline && markupMode == MarkupModeMarkdown) {
|
||||
insertions = append(insertions, &insertion{
|
||||
Offset: i + 1,
|
||||
Runes: quoteRunes,
|
||||
Type: insertionUnpaired,
|
||||
})
|
||||
}
|
||||
|
||||
if isNewline {
|
||||
wasNewline = true
|
||||
} else {
|
||||
wasNewline = false
|
||||
}
|
||||
}
|
||||
|
||||
var rbrace []rune
|
||||
if len(doubledRunes) > entityEndInt {
|
||||
if doubledRunes[entityEnd] == newlineCode {
|
||||
if markupMode == MarkupModeMarkdown && len(doubledRunes) > entityEndInt+1 && doubledRunes[entityEndInt+1] != newlineCode {
|
||||
rbrace = newlineRunes
|
||||
}
|
||||
} else {
|
||||
if markupMode == MarkupModeMarkdown {
|
||||
rbrace = doubleNewlineRunes
|
||||
} else {
|
||||
rbrace = newlineRunes
|
||||
}
|
||||
}
|
||||
}
|
||||
insertions = append(insertions, &insertion{
|
||||
Offset: entityEnd,
|
||||
Runes: rbrace,
|
||||
Type: insertionClosing,
|
||||
})
|
||||
|
||||
return insertions
|
||||
}
|
||||
|
||||
// entityToMarkdown generates the wrapping Markdown tags
|
||||
func entityToMarkdown(entity *client.TextEntity, doubledRunes []rune, markupMode MarkupModeType) []*insertion {
|
||||
if entity == nil || entity.Type == nil {
|
||||
return []*insertion{}
|
||||
}
|
||||
|
||||
// EntityToMarkdown generates the wrapping Markdown tags
|
||||
func EntityToMarkdown(entity *client.TextEntity) (*Insertion, *Insertion) {
|
||||
switch entity.Type.TextEntityTypeType() {
|
||||
case client.TypeTextEntityTypeBold:
|
||||
return markupBraces(entity, boldRunesMarkdown, boldRunesMarkdown)
|
||||
|
|
@ -270,24 +189,22 @@ func entityToMarkdown(entity *client.TextEntity, doubledRunes []rune, markupMode
|
|||
case client.TypeTextEntityTypeCode:
|
||||
return markupBraces(entity, codeRunes, codeRunes)
|
||||
case client.TypeTextEntityTypePre:
|
||||
return markupBraces(entity, preRunesStart, preRunesEnd)
|
||||
return markupBraces(entity, preRuneStart, preRuneEnd)
|
||||
case client.TypeTextEntityTypePreCode:
|
||||
preCode, _ := entity.Type.(*client.TextEntityTypePreCode)
|
||||
return markupBraces(entity, []rune("\n```"+preCode.Language+"\n"), preRunesEnd)
|
||||
case client.TypeTextEntityTypeBlockQuote:
|
||||
return quotePrependNewlines(entity, doubledRunes, MarkupModeMarkdown)
|
||||
return markupBraces(entity, []rune("\n```"+preCode.Language+"\n"), codeRunes)
|
||||
case client.TypeTextEntityTypeTextUrl:
|
||||
textURL, _ := entity.Type.(*client.TextEntityTypeTextUrl)
|
||||
return markupBraces(entity, []rune("["), []rune("]("+textURL.Url+")"))
|
||||
}
|
||||
|
||||
return []*insertion{}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// entityToXEP0393 generates the wrapping XEP-0393 tags
|
||||
func entityToXEP0393(entity *client.TextEntity, doubledRunes []rune, markupMode MarkupModeType) []*insertion {
|
||||
// EntityToXEP0393 generates the wrapping XEP-0393 tags
|
||||
func EntityToXEP0393(entity *client.TextEntity) (*Insertion, *Insertion) {
|
||||
if entity == nil || entity.Type == nil {
|
||||
return []*insertion{}
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
switch entity.Type.TextEntityTypeType() {
|
||||
|
|
@ -300,59 +217,33 @@ func entityToXEP0393(entity *client.TextEntity, doubledRunes []rune, markupMode
|
|||
case client.TypeTextEntityTypeCode:
|
||||
return markupBraces(entity, codeRunes, codeRunes)
|
||||
case client.TypeTextEntityTypePre:
|
||||
return markupBraces(entity, preRunesStart, preRunesEnd)
|
||||
return markupBraces(entity, preRuneStart, preRuneEnd)
|
||||
case client.TypeTextEntityTypePreCode:
|
||||
preCode, _ := entity.Type.(*client.TextEntityTypePreCode)
|
||||
return markupBraces(entity, []rune("\n```"+preCode.Language+"\n"), preRunesEnd)
|
||||
case client.TypeTextEntityTypeBlockQuote:
|
||||
return quotePrependNewlines(entity, doubledRunes, MarkupModeXEP0393)
|
||||
return markupBraces(entity, []rune("\n```"+preCode.Language+"\n"), codeRunes)
|
||||
case client.TypeTextEntityTypeTextUrl:
|
||||
textURL, _ := entity.Type.(*client.TextEntityTypeTextUrl)
|
||||
// non-standard, Pidgin-specific
|
||||
return markupBraces(entity, []rune{}, []rune(" <"+textURL.Url+">"))
|
||||
}
|
||||
|
||||
return []*insertion{}
|
||||
}
|
||||
|
||||
// transform the source text into a form with uniform runes and code points,
|
||||
// by duplicating anything beyond the Basic Multilingual Plane
|
||||
func textToDoubledRunes(text string) []rune {
|
||||
doubledRunes := make([]rune, 0, len(text)*2)
|
||||
for _, cp := range text {
|
||||
if cp > bmpCeil {
|
||||
doubledRunes = append(doubledRunes, cp, cp)
|
||||
} else {
|
||||
doubledRunes = append(doubledRunes, cp)
|
||||
}
|
||||
}
|
||||
|
||||
return doubledRunes
|
||||
return nil, nil
|
||||
}
|
||||
|
||||
// Format traverses an already sorted list of entities and wraps the text in a markup
|
||||
func Format(
|
||||
sourceText string,
|
||||
entities []*client.TextEntity,
|
||||
markupMode MarkupModeType,
|
||||
entityToMarkup func(*client.TextEntity) (*Insertion, *Insertion),
|
||||
) string {
|
||||
if len(entities) == 0 {
|
||||
return sourceText
|
||||
}
|
||||
|
||||
var entityToMarkup func(*client.TextEntity, []rune, MarkupModeType) []*insertion
|
||||
if markupMode == MarkupModeXEP0393 {
|
||||
entityToMarkup = entityToXEP0393
|
||||
} else {
|
||||
entityToMarkup = entityToMarkdown
|
||||
}
|
||||
mergedEntities := SortEntities(ClaspDirectives(sourceText, MergeAdjacentEntities(SortEntities(entities))))
|
||||
|
||||
doubledRunes := textToDoubledRunes(sourceText)
|
||||
|
||||
mergedEntities := SortEntities(ClaspDirectives(doubledRunes, MergeAdjacentEntities(SortEntities(entities))))
|
||||
|
||||
startStack := make(insertionStack, 0, len(sourceText))
|
||||
endStack := make(insertionStack, 0, len(sourceText))
|
||||
startStack := make(InsertionStack, 0, len(sourceText))
|
||||
endStack := make(InsertionStack, 0, len(sourceText))
|
||||
|
||||
// convert entities to a stack of brackets
|
||||
var maxEndOffset int32
|
||||
|
|
@ -369,70 +260,36 @@ func Format(
|
|||
|
||||
startStack, endStack = startStack.rebalance(endStack, entity.Offset)
|
||||
|
||||
insertions := entityToMarkup(entity, doubledRunes, markupMode)
|
||||
if len(insertions) > 1 {
|
||||
startStack = append(startStack, insertions[0:len(insertions)-1]...)
|
||||
startInsertion, endInsertion := entityToMarkup(entity)
|
||||
if startInsertion != nil {
|
||||
startStack = append(startStack, startInsertion)
|
||||
}
|
||||
if len(insertions) > 0 {
|
||||
endStack = append(endStack, insertions[len(insertions)-1])
|
||||
if endInsertion != nil {
|
||||
endStack = append(endStack, endInsertion)
|
||||
}
|
||||
}
|
||||
// flush the closing brackets that still remain in endStack
|
||||
startStack, endStack = startStack.rebalance(endStack, maxEndOffset)
|
||||
// sort unpaired insertions
|
||||
sort.SliceStable(startStack, func(i int, j int) bool {
|
||||
ins1 := startStack[i]
|
||||
ins2 := startStack[j]
|
||||
if ins1.Type == insertionUnpaired && ins2.Type == insertionUnpaired {
|
||||
return ins1.Offset < ins2.Offset
|
||||
}
|
||||
if ins1.Type == insertionUnpaired {
|
||||
if ins1.Offset == ins2.Offset {
|
||||
if ins2.Type == insertionOpening { // > **
|
||||
return true
|
||||
} else if ins2.Type == insertionClosing { // **>
|
||||
return false
|
||||
}
|
||||
} else {
|
||||
return ins1.Offset < ins2.Offset
|
||||
}
|
||||
}
|
||||
if ins2.Type == insertionUnpaired {
|
||||
if ins1.Offset == ins2.Offset {
|
||||
if ins1.Type == insertionOpening { // > **
|
||||
return false
|
||||
} else if ins1.Type == insertionClosing { // **>
|
||||
return true
|
||||
}
|
||||
} else {
|
||||
return ins1.Offset < ins2.Offset
|
||||
}
|
||||
}
|
||||
return false
|
||||
})
|
||||
|
||||
// merge brackets into text
|
||||
markupRunes := make([]rune, 0, len(sourceText))
|
||||
|
||||
nextInsertion := startStack.NewIterator()
|
||||
insertion := nextInsertion()
|
||||
var skipNext bool
|
||||
var runeI int32
|
||||
|
||||
for i, cp := range doubledRunes {
|
||||
if skipNext {
|
||||
skipNext = false
|
||||
continue
|
||||
}
|
||||
|
||||
for insertion != nil && int(insertion.Offset) <= i {
|
||||
for _, cp := range sourceText {
|
||||
for insertion != nil && insertion.Offset <= runeI {
|
||||
markupRunes = append(markupRunes, insertion.Runes...)
|
||||
insertion = nextInsertion()
|
||||
}
|
||||
|
||||
markupRunes = append(markupRunes, cp)
|
||||
// skip two UTF-16 code units (not points actually!) if needed
|
||||
if cp > bmpCeil {
|
||||
skipNext = true
|
||||
if cp > 0x0000ffff {
|
||||
runeI += 2
|
||||
} else {
|
||||
runeI++
|
||||
}
|
||||
}
|
||||
for insertion != nil {
|
||||
|
|
|
|||
|
|
@ -7,7 +7,7 @@ import (
|
|||
)
|
||||
|
||||
func TestNoFormatting(t *testing.T) {
|
||||
markup := Format("abc\ndef", []*client.TextEntity{}, MarkupModeMarkdown)
|
||||
markup := Format("abc\ndef", []*client.TextEntity{}, EntityToMarkdown)
|
||||
if markup != "abc\ndef" {
|
||||
t.Errorf("No formatting expected, but: %v", markup)
|
||||
}
|
||||
|
|
@ -20,7 +20,7 @@ func TestFormattingSimple(t *testing.T) {
|
|||
Length: 4,
|
||||
Type: &client.TextEntityTypeBold{},
|
||||
},
|
||||
}, MarkupModeMarkdown)
|
||||
}, EntityToMarkdown)
|
||||
if markup != "👙**🐧🐖**" {
|
||||
t.Errorf("Wrong simple formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -40,7 +40,7 @@ func TestFormattingAdjacent(t *testing.T) {
|
|||
Url: "https://narayana.im/",
|
||||
},
|
||||
},
|
||||
}, MarkupModeMarkdown)
|
||||
}, EntityToMarkdown)
|
||||
if markup != "a👙_🐧_[🐖](https://narayana.im/)" {
|
||||
t.Errorf("Wrong adjacent formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -63,18 +63,18 @@ func TestFormattingAdjacentAndNested(t *testing.T) {
|
|||
Length: 2,
|
||||
Type: &client.TextEntityTypeItalic{},
|
||||
},
|
||||
}, MarkupModeMarkdown)
|
||||
}, EntityToMarkdown)
|
||||
if markup != "```\n**👙**🐧\n```_🐖_" {
|
||||
t.Errorf("Wrong adjacent&nested formatting: %v", markup)
|
||||
}
|
||||
}
|
||||
|
||||
func TestRebalanceTwoZero(t *testing.T) {
|
||||
s1 := insertionStack{
|
||||
&insertion{Offset: 7},
|
||||
&insertion{Offset: 8},
|
||||
s1 := InsertionStack{
|
||||
&Insertion{Offset: 7},
|
||||
&Insertion{Offset: 8},
|
||||
}
|
||||
s2 := insertionStack{}
|
||||
s2 := InsertionStack{}
|
||||
s1, s2 = s1.rebalance(s2, 7)
|
||||
if !(len(s1) == 2 && len(s2) == 0 && s1[0].Offset == 7 && s1[1].Offset == 8) {
|
||||
t.Errorf("Wrong rebalance 2–0: %#v %#v", s1, s2)
|
||||
|
|
@ -82,13 +82,13 @@ func TestRebalanceTwoZero(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestRebalanceNeeded(t *testing.T) {
|
||||
s1 := insertionStack{
|
||||
&insertion{Offset: 7},
|
||||
&insertion{Offset: 8},
|
||||
s1 := InsertionStack{
|
||||
&Insertion{Offset: 7},
|
||||
&Insertion{Offset: 8},
|
||||
}
|
||||
s2 := insertionStack{
|
||||
&insertion{Offset: 10},
|
||||
&insertion{Offset: 9},
|
||||
s2 := InsertionStack{
|
||||
&Insertion{Offset: 10},
|
||||
&Insertion{Offset: 9},
|
||||
}
|
||||
s1, s2 = s1.rebalance(s2, 9)
|
||||
if !(len(s1) == 3 && len(s2) == 1 &&
|
||||
|
|
@ -99,13 +99,13 @@ func TestRebalanceNeeded(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestRebalanceNotNeeded(t *testing.T) {
|
||||
s1 := insertionStack{
|
||||
&insertion{Offset: 7},
|
||||
&insertion{Offset: 8},
|
||||
s1 := InsertionStack{
|
||||
&Insertion{Offset: 7},
|
||||
&Insertion{Offset: 8},
|
||||
}
|
||||
s2 := insertionStack{
|
||||
&insertion{Offset: 10},
|
||||
&insertion{Offset: 9},
|
||||
s2 := InsertionStack{
|
||||
&Insertion{Offset: 10},
|
||||
&Insertion{Offset: 9},
|
||||
}
|
||||
s1, s2 = s1.rebalance(s2, 8)
|
||||
if !(len(s1) == 2 && len(s2) == 2 &&
|
||||
|
|
@ -116,13 +116,13 @@ func TestRebalanceNotNeeded(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestRebalanceLate(t *testing.T) {
|
||||
s1 := insertionStack{
|
||||
&insertion{Offset: 7},
|
||||
&insertion{Offset: 8},
|
||||
s1 := InsertionStack{
|
||||
&Insertion{Offset: 7},
|
||||
&Insertion{Offset: 8},
|
||||
}
|
||||
s2 := insertionStack{
|
||||
&insertion{Offset: 10},
|
||||
&insertion{Offset: 9},
|
||||
s2 := InsertionStack{
|
||||
&Insertion{Offset: 10},
|
||||
&Insertion{Offset: 9},
|
||||
}
|
||||
s1, s2 = s1.rebalance(s2, 10)
|
||||
if !(len(s1) == 4 && len(s2) == 0 &&
|
||||
|
|
@ -133,7 +133,7 @@ func TestRebalanceLate(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestIteratorEmpty(t *testing.T) {
|
||||
s := insertionStack{}
|
||||
s := InsertionStack{}
|
||||
g := s.NewIterator()
|
||||
v := g()
|
||||
if v != nil {
|
||||
|
|
@ -142,9 +142,9 @@ func TestIteratorEmpty(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestIterator(t *testing.T) {
|
||||
s := insertionStack{
|
||||
&insertion{Offset: 7},
|
||||
&insertion{Offset: 8},
|
||||
s := InsertionStack{
|
||||
&Insertion{Offset: 7},
|
||||
&Insertion{Offset: 8},
|
||||
}
|
||||
g := s.NewIterator()
|
||||
v := g()
|
||||
|
|
@ -208,7 +208,7 @@ func TestSortEmpty(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestNoFormattingXEP0393(t *testing.T) {
|
||||
markup := Format("abc\ndef", []*client.TextEntity{}, MarkupModeXEP0393)
|
||||
markup := Format("abc\ndef", []*client.TextEntity{}, EntityToXEP0393)
|
||||
if markup != "abc\ndef" {
|
||||
t.Errorf("No formatting expected, but: %v", markup)
|
||||
}
|
||||
|
|
@ -221,7 +221,7 @@ func TestFormattingXEP0393Simple(t *testing.T) {
|
|||
Length: 4,
|
||||
Type: &client.TextEntityTypeBold{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
}, EntityToXEP0393)
|
||||
if markup != "👙*🐧🐖*" {
|
||||
t.Errorf("Wrong simple formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -241,7 +241,7 @@ func TestFormattingXEP0393Adjacent(t *testing.T) {
|
|||
Url: "https://narayana.im/",
|
||||
},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
}, EntityToXEP0393)
|
||||
if markup != "a👙_🐧_🐖 <https://narayana.im/>" {
|
||||
t.Errorf("Wrong adjacent formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -264,7 +264,7 @@ func TestFormattingXEP0393AdjacentAndNested(t *testing.T) {
|
|||
Length: 2,
|
||||
Type: &client.TextEntityTypeItalic{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
}, EntityToXEP0393)
|
||||
if markup != "```\n*👙*🐧\n```_🐖_" {
|
||||
t.Errorf("Wrong adjacent&nested formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -287,7 +287,7 @@ func TestFormattingXEP0393AdjacentItalicBoldItalic(t *testing.T) {
|
|||
Length: 69,
|
||||
Type: &client.TextEntityTypeItalic{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
}, EntityToXEP0393)
|
||||
if markup != "_раса двуногих крысолюдей, *которую так редко замечают, что многие отрицают само их существование*_" {
|
||||
t.Errorf("Wrong adjacent italic/bold-italic formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -315,7 +315,7 @@ func TestFormattingXEP0393MultipleAdjacent(t *testing.T) {
|
|||
Length: 1,
|
||||
Type: &client.TextEntityTypeItalic{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
}, EntityToXEP0393)
|
||||
if markup != "a*bcd*_e_" {
|
||||
t.Errorf("Wrong multiple adjacent formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -343,7 +343,7 @@ func TestFormattingXEP0393Intersecting(t *testing.T) {
|
|||
Length: 1,
|
||||
Type: &client.TextEntityTypeBold{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
}, EntityToXEP0393)
|
||||
if markup != "a*b*_*cd*e_" {
|
||||
t.Errorf("Wrong intersecting formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -361,7 +361,7 @@ func TestFormattingXEP0393InlineCode(t *testing.T) {
|
|||
Length: 25,
|
||||
Type: &client.TextEntityTypePre{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
}, EntityToXEP0393)
|
||||
if markup != "Is `Gajim` a thing?\n\n```\necho 'Hello'\necho 'world'\n```\n\nhruck(" {
|
||||
t.Errorf("Wrong intersecting formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -374,7 +374,7 @@ func TestFormattingMarkdownStrikethrough(t *testing.T) {
|
|||
Length: 3,
|
||||
Type: &client.TextEntityTypeStrikethrough{},
|
||||
},
|
||||
}, MarkupModeMarkdown)
|
||||
}, EntityToMarkdown)
|
||||
if markup != "Everyone ~~dis~~likes cake." {
|
||||
t.Errorf("Wrong strikethrough formatting: %v", markup)
|
||||
}
|
||||
|
|
@ -387,14 +387,14 @@ func TestFormattingXEP0393Strikethrough(t *testing.T) {
|
|||
Length: 3,
|
||||
Type: &client.TextEntityTypeStrikethrough{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
}, EntityToXEP0393)
|
||||
if markup != "Everyone ~dis~likes cake." {
|
||||
t.Errorf("Wrong strikethrough formatting: %v", markup)
|
||||
}
|
||||
}
|
||||
|
||||
func TestClaspLeft(t *testing.T) {
|
||||
text := textToDoubledRunes("a b c")
|
||||
text := "a b c"
|
||||
entities := []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 1,
|
||||
|
|
@ -409,7 +409,7 @@ func TestClaspLeft(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestClaspBoth(t *testing.T) {
|
||||
text := textToDoubledRunes("a b c")
|
||||
text := "a b c"
|
||||
entities := []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 1,
|
||||
|
|
@ -424,7 +424,7 @@ func TestClaspBoth(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestClaspNotNeeded(t *testing.T) {
|
||||
text := textToDoubledRunes(" abc ")
|
||||
text := " abc "
|
||||
entities := []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 1,
|
||||
|
|
@ -439,7 +439,7 @@ func TestClaspNotNeeded(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestClaspNested(t *testing.T) {
|
||||
text := textToDoubledRunes("a b c")
|
||||
text := "a b c"
|
||||
entities := []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 1,
|
||||
|
|
@ -459,7 +459,7 @@ func TestClaspNested(t *testing.T) {
|
|||
}
|
||||
|
||||
func TestClaspEmoji(t *testing.T) {
|
||||
text := textToDoubledRunes("a 🐖 c")
|
||||
text := "a 🐖 c"
|
||||
entities := []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 1,
|
||||
|
|
@ -472,111 +472,3 @@ func TestClaspEmoji(t *testing.T) {
|
|||
t.Errorf("Wrong claspemoji: %#v", entities)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNoNewlineBlockquoteXEP0393(t *testing.T) {
|
||||
markup := Format("yes it can i think", []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 4,
|
||||
Length: 6,
|
||||
Type: &client.TextEntityTypeBlockQuote{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
if markup != "yes \n> it can\n i think" {
|
||||
t.Errorf("Wrong blockquote formatting: %v", markup)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNoNewlineBlockquoteMarkdown(t *testing.T) {
|
||||
markup := Format("yes it can i think", []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 4,
|
||||
Length: 6,
|
||||
Type: &client.TextEntityTypeBlockQuote{},
|
||||
},
|
||||
}, MarkupModeMarkdown)
|
||||
if markup != "yes \n> it can\n\n i think" {
|
||||
t.Errorf("Wrong blockquote formatting: %v", markup)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultilineBlockquoteXEP0393(t *testing.T) {
|
||||
markup := Format("hruck\npuck\n\nshuck\ntext", []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 0,
|
||||
Length: 17,
|
||||
Type: &client.TextEntityTypeBlockQuote{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
if markup != "> hruck\n> puck\n> \n> shuck\ntext" {
|
||||
t.Errorf("Wrong blockquote formatting: %v", markup)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMultilineBlockquoteMarkdown(t *testing.T) {
|
||||
markup := Format("hruck\npuck\n\nshuck\ntext", []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 0,
|
||||
Length: 17,
|
||||
Type: &client.TextEntityTypeBlockQuote{},
|
||||
},
|
||||
}, MarkupModeMarkdown)
|
||||
if markup != "> hruck\npuck\n\n> shuck\n\ntext" {
|
||||
t.Errorf("Wrong blockquote formatting: %v", markup)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMixedBlockquoteXEP0393(t *testing.T) {
|
||||
markup := Format("hruck\npuck\nshuck\ntext", []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 0,
|
||||
Length: 16,
|
||||
Type: &client.TextEntityTypeBlockQuote{},
|
||||
},
|
||||
&client.TextEntity{
|
||||
Offset: 0,
|
||||
Length: 16,
|
||||
Type: &client.TextEntityTypeBold{},
|
||||
},
|
||||
&client.TextEntity{
|
||||
Offset: 0,
|
||||
Length: 10,
|
||||
Type: &client.TextEntityTypeItalic{},
|
||||
},
|
||||
&client.TextEntity{
|
||||
Offset: 7,
|
||||
Length: 2,
|
||||
Type: &client.TextEntityTypeStrikethrough{},
|
||||
},
|
||||
}, MarkupModeXEP0393)
|
||||
if markup != "> *_hruck\n> p~uc~k_\n> shuck*\ntext" {
|
||||
t.Errorf("Wrong blockquote formatting: %v", markup)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMixedBlockquoteMarkdown(t *testing.T) {
|
||||
markup := Format("hruck\npuck\nshuck\ntext", []*client.TextEntity{
|
||||
&client.TextEntity{
|
||||
Offset: 0,
|
||||
Length: 16,
|
||||
Type: &client.TextEntityTypeBlockQuote{},
|
||||
},
|
||||
&client.TextEntity{
|
||||
Offset: 0,
|
||||
Length: 16,
|
||||
Type: &client.TextEntityTypeBold{},
|
||||
},
|
||||
&client.TextEntity{
|
||||
Offset: 0,
|
||||
Length: 10,
|
||||
Type: &client.TextEntityTypeItalic{},
|
||||
},
|
||||
&client.TextEntity{
|
||||
Offset: 7,
|
||||
Length: 2,
|
||||
Type: &client.TextEntityTypeStrikethrough{},
|
||||
},
|
||||
}, MarkupModeMarkdown)
|
||||
if markup != "> **_hruck\np~~uc~~k_\nshuck**\n\ntext" {
|
||||
t.Errorf("Wrong blockquote formatting: %v", markup)
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -55,31 +55,6 @@ func (c *Client) cleanTempFile(path string) {
|
|||
}
|
||||
}
|
||||
|
||||
func (c *Client) sendMarker(chatId, messageId int64, typ gateway.MarkerType) {
|
||||
xmppId, err := gateway.IdsDB.GetByTgIds(c.Session.Login, c.jid, chatId, messageId)
|
||||
if err != nil {
|
||||
xmppId = strconv.FormatInt(messageId, 10)
|
||||
}
|
||||
|
||||
var stringType string
|
||||
if typ == gateway.MarkerTypeReceived {
|
||||
stringType = "received"
|
||||
} else if typ == gateway.MarkerTypeDisplayed {
|
||||
stringType = "displayed"
|
||||
}
|
||||
log.WithFields(log.Fields{
|
||||
"xmppId": xmppId,
|
||||
}).Debugf("marker: %s", stringType)
|
||||
|
||||
gateway.SendMessageMarker(
|
||||
c.jid,
|
||||
strconv.FormatInt(chatId, 10),
|
||||
c.xmpp,
|
||||
typ,
|
||||
xmppId,
|
||||
)
|
||||
}
|
||||
|
||||
func (c *Client) updateHandler() {
|
||||
listener := c.client.GetListener()
|
||||
defer listener.Close()
|
||||
|
|
@ -166,12 +141,6 @@ func (c *Client) updateHandler() {
|
|||
uhOh()
|
||||
}
|
||||
c.updateChatTitle(typedUpdate)
|
||||
case client.TypeUpdateChatReadOutbox:
|
||||
typedUpdate, ok := update.(*client.UpdateChatReadOutbox)
|
||||
if !ok {
|
||||
uhOh()
|
||||
}
|
||||
c.updateChatReadOutbox(typedUpdate)
|
||||
default:
|
||||
// log only handled types
|
||||
continue
|
||||
|
|
@ -234,19 +203,14 @@ func (c *Client) updateChatLastMessage(update *client.UpdateChatLastMessage) {
|
|||
|
||||
// message received
|
||||
func (c *Client) updateNewMessage(update *client.UpdateNewMessage) {
|
||||
chatId := update.Message.ChatId
|
||||
if c.Session.IsChatIgnored(chatId) {
|
||||
return
|
||||
}
|
||||
|
||||
// guarantee sequential message delivering per chat
|
||||
lock := c.getChatMessageLock(chatId)
|
||||
go func() {
|
||||
chatId := update.Message.ChatId
|
||||
|
||||
// guarantee sequential message delivering per chat
|
||||
lock := c.getChatMessageLock(chatId)
|
||||
lock.Lock()
|
||||
defer lock.Unlock()
|
||||
|
||||
c.updateLastMessageHash(update.Message.ChatId, update.Message.Id, update.Message.Content)
|
||||
|
||||
// ignore self outgoing messages
|
||||
if update.Message.IsOutgoing &&
|
||||
update.Message.SendingState != nil &&
|
||||
|
|
@ -264,106 +228,27 @@ func (c *Client) updateNewMessage(update *client.UpdateNewMessage) {
|
|||
|
||||
// message content updated
|
||||
func (c *Client) updateMessageContent(update *client.UpdateMessageContent) {
|
||||
if c.Session.IsChatIgnored(update.ChatId) {
|
||||
return
|
||||
}
|
||||
|
||||
markupFunction := c.getFormatter()
|
||||
|
||||
defer c.updateLastMessageHash(update.ChatId, update.MessageId, update.NewContent)
|
||||
|
||||
log.Debugf("newContent: %#v", update.NewContent)
|
||||
|
||||
lock := c.getChatMessageLock(update.ChatId)
|
||||
lock.Lock()
|
||||
lock.Unlock()
|
||||
c.SendMessageLock.Lock()
|
||||
c.SendMessageLock.Unlock()
|
||||
|
||||
xmppId, xmppIdErr := gateway.IdsDB.GetByTgIds(c.Session.Login, c.jid, update.ChatId, update.MessageId)
|
||||
var ignoredResource string
|
||||
if xmppIdErr == nil {
|
||||
ignoredResource = c.popFromEditOutbox(xmppId)
|
||||
} else {
|
||||
log.Infof("Couldn't retrieve XMPP message ids for %v, an echo may happen", update.MessageId)
|
||||
}
|
||||
log.Infof("ignoredResource: %v", ignoredResource)
|
||||
|
||||
jids := c.getCarbonFullJids(true, ignoredResource)
|
||||
if len(jids) == 0 {
|
||||
log.Info("The only resource is ignored, aborting")
|
||||
return
|
||||
}
|
||||
|
||||
if update.NewContent.MessageContentType() == client.TypeMessageText && c.hasLastMessageHashChanged(update.ChatId, update.MessageId, update.NewContent) {
|
||||
markupFunction := formatter.EntityToXEP0393
|
||||
if update.NewContent.MessageContentType() == client.TypeMessageText {
|
||||
textContent := update.NewContent.(*client.MessageText)
|
||||
log.Debugf("textContent: %#v", textContent.Text)
|
||||
|
||||
var replaceId string
|
||||
sId := strconv.FormatInt(update.MessageId, 10)
|
||||
var isCarbon bool
|
||||
|
||||
// use XEP-0308 edits only if the last message is edited for sure, fallback otherwise
|
||||
if c.Session.NativeEdits {
|
||||
lastXmppId, ok := c.getLastChatMessageId(update.ChatId)
|
||||
if xmppIdErr != nil {
|
||||
xmppId = sId
|
||||
}
|
||||
if ok && lastXmppId == xmppId {
|
||||
replaceId = xmppId
|
||||
} else {
|
||||
log.Infof("Mismatching message ids: %v %v, falling back to separate edit message", lastXmppId, xmppId)
|
||||
}
|
||||
}
|
||||
|
||||
message, messageErr := c.client.GetMessage(&client.GetMessageRequest{
|
||||
ChatId: update.ChatId,
|
||||
MessageId: update.MessageId,
|
||||
})
|
||||
var prefix string
|
||||
if messageErr == nil {
|
||||
isCarbon = c.isCarbonsEnabled() && message.IsOutgoing
|
||||
// reply correction support in clients is suboptimal yet, so cut them out for now
|
||||
prefix, _ = c.messageToPrefix(message, "", "", true)
|
||||
var editChar string
|
||||
if c.Session.AsciiArrows {
|
||||
editChar = "e "
|
||||
} else {
|
||||
log.Errorf("No message %v/%v found, cannot reliably determine if it's a carbon", update.ChatId, update.MessageId)
|
||||
editChar = "✎ "
|
||||
}
|
||||
|
||||
var text strings.Builder
|
||||
|
||||
if replaceId == "" {
|
||||
var editChar string
|
||||
if c.Session.AsciiArrows {
|
||||
editChar = "e"
|
||||
} else {
|
||||
editChar = "✎"
|
||||
}
|
||||
text.WriteString(fmt.Sprintf("%s %v | ", editChar, update.MessageId))
|
||||
} else if prefix != "" {
|
||||
text.WriteString(prefix)
|
||||
text.WriteString(c.getPrefixSeparator(update.ChatId))
|
||||
}
|
||||
|
||||
text.WriteString(formatter.Format(
|
||||
text := editChar + fmt.Sprintf("%v | %s", update.MessageId, formatter.Format(
|
||||
textContent.Text.Text,
|
||||
textContent.Text.Entities,
|
||||
markupFunction,
|
||||
))
|
||||
|
||||
sChatId := strconv.FormatInt(update.ChatId, 10)
|
||||
for _, jid := range jids {
|
||||
gateway.SendMessage(jid, sChatId, text.String(), "e"+sId, c.xmpp, nil, replaceId, isCarbon, false)
|
||||
}
|
||||
gateway.SendMessage(c.jid, strconv.FormatInt(update.ChatId, 10), text, "e"+strconv.FormatInt(update.MessageId, 10), c.xmpp, nil, false, "")
|
||||
}
|
||||
}
|
||||
|
||||
// message(s) deleted
|
||||
func (c *Client) updateDeleteMessages(update *client.UpdateDeleteMessages) {
|
||||
if update.IsPermanent {
|
||||
if c.Session.IsChatIgnored(update.ChatId) {
|
||||
return
|
||||
}
|
||||
|
||||
var deleteChar string
|
||||
if c.Session.AsciiArrows {
|
||||
deleteChar = "X "
|
||||
|
|
@ -385,25 +270,19 @@ func (c *Client) updateAuthorizationState(update *client.UpdateAuthorizationStat
|
|||
}
|
||||
}
|
||||
|
||||
// clean uploaded files
|
||||
func (c *Client) updateMessageSendSucceeded(update *client.UpdateMessageSendSucceeded) {
|
||||
// replace message ID in local database
|
||||
log.Debugf("replace message %v with %v", update.OldMessageId, update.Message.Id)
|
||||
if err := gateway.IdsDB.ReplaceTgId(c.Session.Login, c.jid, update.Message.ChatId, update.OldMessageId, update.Message.Id); err != nil {
|
||||
log.Errorf("failed to replace %v with %v: %v", update.OldMessageId, update.Message.Id, err.Error())
|
||||
}
|
||||
|
||||
c.updateLastMessageHash(update.Message.ChatId, update.Message.Id, update.Message.Content)
|
||||
|
||||
c.sendMarker(update.Message.ChatId, update.Message.Id, gateway.MarkerTypeReceived)
|
||||
|
||||
// clean uploaded files
|
||||
file, _ := c.contentToFile(update.Message.Content)
|
||||
if file != nil && file.Local != nil {
|
||||
c.cleanTempFile(file.Local.Path)
|
||||
}
|
||||
}
|
||||
func (c *Client) updateMessageSendFailed(update *client.UpdateMessageSendFailed) {
|
||||
// clean uploaded files
|
||||
file, _ := c.contentToFile(update.Message.Content)
|
||||
if file != nil && file.Local != nil {
|
||||
c.cleanTempFile(file.Local.Path)
|
||||
|
|
@ -415,17 +294,8 @@ func (c *Client) updateChatTitle(update *client.UpdateChatTitle) {
|
|||
gateway.SetNickname(c.jid, strconv.FormatInt(update.ChatId, 10), update.Title, c.xmpp)
|
||||
|
||||
// set also the status (for group chats only)
|
||||
chat, user, _ := c.GetContactByID(update.ChatId, nil)
|
||||
_, user, _ := c.GetContactByID(update.ChatId, nil)
|
||||
if user == nil {
|
||||
c.ProcessStatusUpdate(update.ChatId, update.Title, "chat", gateway.SPImmed(true))
|
||||
}
|
||||
|
||||
// update chat title in the cache
|
||||
if chat != nil {
|
||||
chat.Title = update.Title
|
||||
}
|
||||
}
|
||||
|
||||
func (c *Client) updateChatReadOutbox(update *client.UpdateChatReadOutbox) {
|
||||
c.sendMarker(update.ChatId, update.LastReadOutboxMessageId, gateway.MarkerTypeDisplayed)
|
||||
}
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -369,53 +369,6 @@ func TestMessageAnimation(t *testing.T) {
|
|||
}
|
||||
}
|
||||
|
||||
func TestMessageTtl1(t *testing.T) {
|
||||
ttl := client.Message{
|
||||
Content: &client.MessageChatSetMessageAutoDeleteTime{},
|
||||
}
|
||||
text := (&Client{}).messageToText(&ttl, false)
|
||||
if text != "The self-destruct timer was disabled" {
|
||||
t.Errorf("Wrong anonymous off ttl label: %v", text)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageTtl2(t *testing.T) {
|
||||
ttl := client.Message{
|
||||
Content: &client.MessageChatSetMessageAutoDeleteTime{
|
||||
MessageAutoDeleteTime: 3,
|
||||
},
|
||||
}
|
||||
text := (&Client{}).messageToText(&ttl, false)
|
||||
if text != "The self-destruct timer was set to 3 seconds" {
|
||||
t.Errorf("Wrong anonymous ttl label: %v", text)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageTtl3(t *testing.T) {
|
||||
ttl := client.Message{
|
||||
Content: &client.MessageChatSetMessageAutoDeleteTime{
|
||||
FromUserId: 3,
|
||||
},
|
||||
}
|
||||
text := (&Client{}).messageToText(&ttl, false)
|
||||
if text != "unknown contact: TDlib instance is offline disabled the self-destruct timer" {
|
||||
t.Errorf("Wrong off ttl label: %v", text)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageTtl4(t *testing.T) {
|
||||
ttl := client.Message{
|
||||
Content: &client.MessageChatSetMessageAutoDeleteTime{
|
||||
FromUserId: 3,
|
||||
MessageAutoDeleteTime: 3,
|
||||
},
|
||||
}
|
||||
text := (&Client{}).messageToText(&ttl, false)
|
||||
if text != "unknown contact: TDlib instance is offline set the self-destruct timer to 3 seconds" {
|
||||
t.Errorf("Wrong ttl label: %v", text)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageUnknown(t *testing.T) {
|
||||
unknown := client.Message{
|
||||
Content: &client.MessageExpiredPhoto{},
|
||||
|
|
@ -431,17 +384,20 @@ func TestMessageToPrefix1(t *testing.T) {
|
|||
Id: 42,
|
||||
IsOutgoing: true,
|
||||
ForwardInfo: &client.MessageForwardInfo{
|
||||
Origin: &client.MessageOriginHiddenUser{
|
||||
Origin: &client.MessageForwardOriginHiddenUser{
|
||||
SenderName: "ziz",
|
||||
},
|
||||
},
|
||||
}
|
||||
prefix, gatewayReply := (&Client{Session: &persistence.Session{}}).messageToPrefix(&message, "", "", false)
|
||||
prefix, replyStart, replyEnd := (&Client{Session: &persistence.Session{}}).messageToPrefix(&message, "", "", nil)
|
||||
if prefix != "➡ 42 | fwd: ziz" {
|
||||
t.Errorf("Wrong prefix: %v", prefix)
|
||||
}
|
||||
if gatewayReply != nil {
|
||||
t.Errorf("Reply is not nil: %v", gatewayReply)
|
||||
if replyStart != 0 {
|
||||
t.Errorf("Wrong replyStart: %v", replyStart)
|
||||
}
|
||||
if replyEnd != 0 {
|
||||
t.Errorf("Wrong replyEnd: %v", replyEnd)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -449,17 +405,20 @@ func TestMessageToPrefix2(t *testing.T) {
|
|||
message := client.Message{
|
||||
Id: 56,
|
||||
ForwardInfo: &client.MessageForwardInfo{
|
||||
Origin: &client.MessageOriginChannel{
|
||||
Origin: &client.MessageForwardOriginChannel{
|
||||
AuthorSignature: "zaz",
|
||||
},
|
||||
},
|
||||
}
|
||||
prefix, gatewayReply := (&Client{Session: &persistence.Session{}}).messageToPrefix(&message, "y.jpg", "", false)
|
||||
prefix, replyStart, replyEnd := (&Client{Session: &persistence.Session{}}).messageToPrefix(&message, "y.jpg", "", nil)
|
||||
if prefix != "⬅ 56 | fwd: (zaz) | preview: y.jpg" {
|
||||
t.Errorf("Wrong prefix: %v", prefix)
|
||||
}
|
||||
if gatewayReply != nil {
|
||||
t.Errorf("Reply is not nil: %v", gatewayReply)
|
||||
if replyStart != 0 {
|
||||
t.Errorf("Wrong replyStart: %v", replyStart)
|
||||
}
|
||||
if replyEnd != 0 {
|
||||
t.Errorf("Wrong replyEnd: %v", replyEnd)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -467,17 +426,20 @@ func TestMessageToPrefix3(t *testing.T) {
|
|||
message := client.Message{
|
||||
Id: 56,
|
||||
ForwardInfo: &client.MessageForwardInfo{
|
||||
Origin: &client.MessageOriginChannel{
|
||||
Origin: &client.MessageForwardOriginChannel{
|
||||
AuthorSignature: "zuz",
|
||||
},
|
||||
},
|
||||
}
|
||||
prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "a.jpg", false)
|
||||
prefix, replyStart, replyEnd := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "a.jpg", nil)
|
||||
if prefix != "< 56 | fwd: (zuz) | file: a.jpg" {
|
||||
t.Errorf("Wrong prefix: %v", prefix)
|
||||
}
|
||||
if gatewayReply != nil {
|
||||
t.Errorf("Reply is not nil: %v", gatewayReply)
|
||||
if replyStart != 0 {
|
||||
t.Errorf("Wrong replyStart: %v", replyStart)
|
||||
}
|
||||
if replyEnd != 0 {
|
||||
t.Errorf("Wrong replyEnd: %v", replyEnd)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -486,12 +448,15 @@ func TestMessageToPrefix4(t *testing.T) {
|
|||
Id: 23,
|
||||
IsOutgoing: true,
|
||||
}
|
||||
prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", false)
|
||||
prefix, replyStart, replyEnd := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", nil)
|
||||
if prefix != "> 23" {
|
||||
t.Errorf("Wrong prefix: %v", prefix)
|
||||
}
|
||||
if gatewayReply != nil {
|
||||
t.Errorf("Reply is not nil: %v", gatewayReply)
|
||||
if replyStart != 0 {
|
||||
t.Errorf("Wrong replyStart: %v", replyStart)
|
||||
}
|
||||
if replyEnd != 0 {
|
||||
t.Errorf("Wrong replyEnd: %v", replyEnd)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -499,95 +464,46 @@ func TestMessageToPrefix5(t *testing.T) {
|
|||
message := client.Message{
|
||||
Id: 560,
|
||||
ForwardInfo: &client.MessageForwardInfo{
|
||||
Origin: &client.MessageOriginChat{
|
||||
Origin: &client.MessageForwardOriginChat{
|
||||
AuthorSignature: "zyz",
|
||||
},
|
||||
},
|
||||
}
|
||||
prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "h.jpg", "a.jpg", false)
|
||||
prefix, replyStart, replyEnd := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "h.jpg", "a.jpg", nil)
|
||||
if prefix != "< 560 | fwd: (zyz) | preview: h.jpg | file: a.jpg" {
|
||||
t.Errorf("Wrong prefix: %v", prefix)
|
||||
}
|
||||
if gatewayReply != nil {
|
||||
t.Errorf("Reply is not nil: %v", gatewayReply)
|
||||
if replyStart != 0 {
|
||||
t.Errorf("Wrong replyStart: %v", replyStart)
|
||||
}
|
||||
if replyEnd != 0 {
|
||||
t.Errorf("Wrong replyEnd: %v", replyEnd)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageToPrefix6(t *testing.T) {
|
||||
message := client.Message{
|
||||
Id: 23,
|
||||
ChatId: 25,
|
||||
IsOutgoing: true,
|
||||
ReplyTo: &client.MessageReplyToMessage{
|
||||
ChatId: 41,
|
||||
Quote: &client.TextQuote{
|
||||
Text: &client.FormattedText{
|
||||
Text: "tist\nuz\niz",
|
||||
},
|
||||
},
|
||||
Origin: &client.MessageOriginHiddenUser{
|
||||
SenderName: "ziz",
|
||||
Id: 23,
|
||||
IsOutgoing: true,
|
||||
ReplyToMessageId: 42,
|
||||
}
|
||||
reply := client.Message{
|
||||
Id: 42,
|
||||
Content: &client.MessageText{
|
||||
Text: &client.FormattedText{
|
||||
Text: "tist",
|
||||
},
|
||||
},
|
||||
}
|
||||
prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", false)
|
||||
if prefix != "> 23 | reply: ziz @ unknown contact: TDlib instance is offline | tist uz iz" {
|
||||
prefix, replyStart, replyEnd := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", &reply)
|
||||
if prefix != "> 23 | reply: 42 | | tist" {
|
||||
t.Errorf("Wrong prefix: %v", prefix)
|
||||
}
|
||||
if gatewayReply != nil {
|
||||
t.Errorf("Reply is not nil: %v", gatewayReply)
|
||||
if replyStart != 4 {
|
||||
t.Errorf("Wrong replyStart: %v", replyStart)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageToPrefix7(t *testing.T) {
|
||||
message := client.Message{
|
||||
Id: 23,
|
||||
ChatId: 42,
|
||||
IsOutgoing: true,
|
||||
ReplyTo: &client.MessageReplyToMessage{
|
||||
ChatId: 41,
|
||||
Content: &client.MessageText{
|
||||
Text: &client.FormattedText{
|
||||
Text: "tist",
|
||||
},
|
||||
},
|
||||
Origin: &client.MessageOriginChannel{
|
||||
AuthorSignature: "zaz",
|
||||
},
|
||||
},
|
||||
}
|
||||
prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", false)
|
||||
if prefix != "> 23 | reply: (zaz) @ unknown contact: TDlib instance is offline | tist" {
|
||||
t.Errorf("Wrong prefix: %v", prefix)
|
||||
}
|
||||
if gatewayReply != nil {
|
||||
t.Errorf("Reply is not nil: %v", gatewayReply)
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessageToPrefix8(t *testing.T) {
|
||||
message := client.Message{
|
||||
Id: 23,
|
||||
ChatId: 42,
|
||||
IsOutgoing: true,
|
||||
ReplyTo: &client.MessageReplyToMessage{
|
||||
ChatId: 41,
|
||||
Content: &client.MessageText{
|
||||
Text: &client.FormattedText{
|
||||
Text: "tist",
|
||||
},
|
||||
},
|
||||
Origin: &client.MessageOriginChannel{
|
||||
AuthorSignature: "zuz",
|
||||
},
|
||||
},
|
||||
}
|
||||
prefix, gatewayReply := (&Client{Session: &persistence.Session{AsciiArrows: true}}).messageToPrefix(&message, "", "", true)
|
||||
if prefix != "> 23" {
|
||||
t.Errorf("Wrong prefix: %v", prefix)
|
||||
}
|
||||
if gatewayReply != nil {
|
||||
t.Errorf("Reply is not nil: %v", gatewayReply)
|
||||
if replyEnd != 26 {
|
||||
t.Errorf("Wrong replyEnd: %v", replyEnd)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -7,8 +7,8 @@ import (
|
|||
"gosrc.io/xmpp/stanza"
|
||||
)
|
||||
|
||||
// PresenceNickExtension is from XEP-0172
|
||||
type PresenceNickExtension struct {
|
||||
// NickExtension is from XEP-0172
|
||||
type NickExtension struct {
|
||||
XMLName xml.Name `xml:"http://jabber.org/protocol/nick nick"`
|
||||
Text string `xml:",chardata"`
|
||||
}
|
||||
|
|
@ -154,19 +154,12 @@ type CarbonSent struct {
|
|||
}
|
||||
|
||||
// ComponentPrivilege is from XEP-0356
|
||||
type ComponentPrivilege1 struct {
|
||||
type ComponentPrivilege struct {
|
||||
XMLName xml.Name `xml:"urn:xmpp:privilege:1 privilege"`
|
||||
Perms []ComponentPerm `xml:"perm"`
|
||||
Forwarded stanza.Forwarded `xml:"urn:xmpp:forward:0 forwarded"`
|
||||
}
|
||||
|
||||
// ComponentPrivilege is from XEP-0356
|
||||
type ComponentPrivilege2 struct {
|
||||
XMLName xml.Name `xml:"urn:xmpp:privilege:2 privilege"`
|
||||
Perms []ComponentPerm `xml:"perm"`
|
||||
Forwarded stanza.Forwarded `xml:"urn:xmpp:forward:0 forwarded"`
|
||||
}
|
||||
|
||||
// ComponentPerm is from XEP-0356
|
||||
type ComponentPerm struct {
|
||||
XMLName xml.Name `xml:"perm"`
|
||||
|
|
@ -193,28 +186,8 @@ type Replace struct {
|
|||
Id string `xml:"id,attr"`
|
||||
}
|
||||
|
||||
// QueryRegister is from XEP-0077
|
||||
type QueryRegister struct {
|
||||
XMLName xml.Name `xml:"jabber:iq:register query"`
|
||||
Instructions string `xml:"instructions"`
|
||||
Username string `xml:"username"`
|
||||
Registered *QueryRegisterRegistered `xml:"registered"`
|
||||
Remove *QueryRegisterRemove `xml:"remove"`
|
||||
ResultSet *stanza.ResultSet `xml:"set,omitempty"`
|
||||
}
|
||||
|
||||
// QueryRegisterRegistered is a child element from XEP-0077
|
||||
type QueryRegisterRegistered struct {
|
||||
XMLName xml.Name `xml:"registered"`
|
||||
}
|
||||
|
||||
// QueryRegisterRemove is a child element from XEP-0077
|
||||
type QueryRegisterRemove struct {
|
||||
XMLName xml.Name `xml:"remove"`
|
||||
}
|
||||
|
||||
// Namespace is a namespace!
|
||||
func (c PresenceNickExtension) Namespace() string {
|
||||
func (c NickExtension) Namespace() string {
|
||||
return c.XMLName.Space
|
||||
}
|
||||
|
||||
|
|
@ -254,12 +227,7 @@ func (c CarbonSent) Namespace() string {
|
|||
}
|
||||
|
||||
// Namespace is a namespace!
|
||||
func (c ComponentPrivilege1) Namespace() string {
|
||||
return c.XMLName.Space
|
||||
}
|
||||
|
||||
// Namespace is a namespace!
|
||||
func (c ComponentPrivilege2) Namespace() string {
|
||||
func (c ComponentPrivilege) Namespace() string {
|
||||
return c.XMLName.Space
|
||||
}
|
||||
|
||||
|
|
@ -268,16 +236,6 @@ func (c Replace) Namespace() string {
|
|||
return c.XMLName.Space
|
||||
}
|
||||
|
||||
// Namespace is a namespace!
|
||||
func (c QueryRegister) Namespace() string {
|
||||
return c.XMLName.Space
|
||||
}
|
||||
|
||||
// GetSet getsets!
|
||||
func (c QueryRegister) GetSet() *stanza.ResultSet {
|
||||
return c.ResultSet
|
||||
}
|
||||
|
||||
// Name is a packet name
|
||||
func (ClientMessage) Name() string {
|
||||
return "message"
|
||||
|
|
@ -301,7 +259,13 @@ func init() {
|
|||
stanza.TypeRegistry.MapExtension(stanza.PKTPresence, xml.Name{
|
||||
"http://jabber.org/protocol/nick",
|
||||
"nick",
|
||||
}, PresenceNickExtension{})
|
||||
}, NickExtension{})
|
||||
|
||||
// message nick
|
||||
stanza.TypeRegistry.MapExtension(stanza.PKTMessage, xml.Name{
|
||||
"http://jabber.org/protocol/nick",
|
||||
"nick",
|
||||
}, NickExtension{})
|
||||
|
||||
// presence vcard update
|
||||
stanza.TypeRegistry.MapExtension(stanza.PKTPresence, xml.Name{
|
||||
|
|
@ -339,27 +303,15 @@ func init() {
|
|||
"sent",
|
||||
}, CarbonSent{})
|
||||
|
||||
// component privilege v1
|
||||
// component privilege
|
||||
stanza.TypeRegistry.MapExtension(stanza.PKTMessage, xml.Name{
|
||||
"urn:xmpp:privilege:1",
|
||||
"privilege",
|
||||
}, ComponentPrivilege1{})
|
||||
|
||||
// component privilege v2
|
||||
stanza.TypeRegistry.MapExtension(stanza.PKTMessage, xml.Name{
|
||||
"urn:xmpp:privilege:2",
|
||||
"privilege",
|
||||
}, ComponentPrivilege2{})
|
||||
}, ComponentPrivilege{})
|
||||
|
||||
// message edit
|
||||
stanza.TypeRegistry.MapExtension(stanza.PKTMessage, xml.Name{
|
||||
"urn:xmpp:message-correct:0",
|
||||
"replace",
|
||||
}, Replace{})
|
||||
|
||||
// register query
|
||||
stanza.TypeRegistry.MapExtension(stanza.PKTIQ, xml.Name{
|
||||
"jabber:iq:register",
|
||||
"query",
|
||||
}, QueryRegister{})
|
||||
}
|
||||
|
|
|
|||
|
|
@ -3,14 +3,12 @@ package gateway
|
|||
import (
|
||||
"encoding/xml"
|
||||
"github.com/pkg/errors"
|
||||
"strconv"
|
||||
"strings"
|
||||
"sync"
|
||||
|
||||
"dev.narayana.im/narayana/telegabber/badger"
|
||||
"dev.narayana.im/narayana/telegabber/xmpp/extensions"
|
||||
|
||||
"github.com/google/uuid"
|
||||
log "github.com/sirupsen/logrus"
|
||||
"github.com/soheilhy/args"
|
||||
"gosrc.io/xmpp"
|
||||
|
|
@ -24,18 +22,6 @@ type Reply struct {
|
|||
End uint64
|
||||
}
|
||||
|
||||
type MarkerType byte
|
||||
|
||||
const (
|
||||
MarkerTypeReceived MarkerType = iota
|
||||
MarkerTypeDisplayed
|
||||
)
|
||||
|
||||
type marker struct {
|
||||
Type MarkerType
|
||||
Id string
|
||||
}
|
||||
|
||||
const NSNick string = "http://jabber.org/protocol/nick"
|
||||
|
||||
// Queue stores presences to send later
|
||||
|
|
@ -52,46 +38,30 @@ var IdsDB badger.IdsDB
|
|||
// were changed and need to be re-flushed to the YamlDB
|
||||
var DirtySessions = false
|
||||
|
||||
// MessageOutgoingPermissionVersion contains a XEP-0356 version to fake outgoing messages by foreign JIDs
|
||||
var MessageOutgoingPermissionVersion = 0
|
||||
// MessageOutgoingPermission allows to fake outgoing messages by foreign JIDs
|
||||
var MessageOutgoingPermission = false
|
||||
|
||||
// SendMessage creates and sends a message stanza
|
||||
func SendMessage(to string, from string, body string, id string, component *xmpp.Component, reply *Reply, replaceId string, isCarbon, requestReceipt bool) {
|
||||
sendMessageWrapper(to, from, body, id, component, reply, nil, "", replaceId, isCarbon, requestReceipt)
|
||||
func SendMessage(to string, from string, body string, id string, component *xmpp.Component, reply *Reply, isOutgoing bool, nick string) {
|
||||
sendMessageWrapper(to, from, body, id, component, reply, "", isOutgoing, nick)
|
||||
}
|
||||
|
||||
// SendServiceMessage creates and sends a simple message stanza from transport
|
||||
func SendServiceMessage(to string, body string, component *xmpp.Component) {
|
||||
var id string
|
||||
if uuid, err := uuid.NewRandom(); err == nil {
|
||||
id = uuid.String()
|
||||
}
|
||||
sendMessageWrapper(to, "", body, id, component, nil, nil, "", "", false, false)
|
||||
sendMessageWrapper(to, "", body, "", component, nil, "", false, "")
|
||||
}
|
||||
|
||||
// SendTextMessage creates and sends a simple message stanza
|
||||
func SendTextMessage(to string, from string, body string, component *xmpp.Component) {
|
||||
var id string
|
||||
if uuid, err := uuid.NewRandom(); err == nil {
|
||||
id = uuid.String()
|
||||
}
|
||||
sendMessageWrapper(to, from, body, id, component, nil, nil, "", "", false, false)
|
||||
sendMessageWrapper(to, from, body, "", component, nil, "", false, "")
|
||||
}
|
||||
|
||||
// SendMessageWithOOB creates and sends a message stanza with OOB URL
|
||||
func SendMessageWithOOB(to string, from string, body string, id string, component *xmpp.Component, reply *Reply, oob, replaceId string, isCarbon, requestReceipt bool) {
|
||||
sendMessageWrapper(to, from, body, id, component, reply, nil, oob, replaceId, isCarbon, requestReceipt)
|
||||
func SendMessageWithOOB(to string, from string, body string, id string, component *xmpp.Component, reply *Reply, oob string, isOutgoing bool, nick string) {
|
||||
sendMessageWrapper(to, from, body, id, component, reply, oob, isOutgoing, nick)
|
||||
}
|
||||
|
||||
// SendMessageMarker creates and sends a message stanza with a XEP-0333 marker
|
||||
func SendMessageMarker(to string, from string, component *xmpp.Component, markerType MarkerType, markerId string) {
|
||||
sendMessageWrapper(to, from, "", "", component, nil, &marker{
|
||||
Type: markerType,
|
||||
Id: markerId,
|
||||
}, "", "", false, false)
|
||||
}
|
||||
|
||||
func sendMessageWrapper(to string, from string, body string, id string, component *xmpp.Component, reply *Reply, marker *marker, oob, replaceId string, isCarbon, requestReceipt bool) {
|
||||
func sendMessageWrapper(to string, from string, body string, id string, component *xmpp.Component, reply *Reply, oob string, isOutgoing bool, nick string) {
|
||||
toJid, err := stanza.NewJid(to)
|
||||
if err != nil {
|
||||
log.WithFields(log.Fields{
|
||||
|
|
@ -113,7 +83,7 @@ func sendMessageWrapper(to string, from string, body string, id string, componen
|
|||
logFrom = from
|
||||
messageFrom = from + "@" + componentJid
|
||||
}
|
||||
if isCarbon {
|
||||
if isOutgoing {
|
||||
messageTo = messageFrom
|
||||
messageFrom = bareTo + "/" + Jid.Resource
|
||||
} else {
|
||||
|
|
@ -149,25 +119,13 @@ func sendMessageWrapper(to string, from string, body string, id string, componen
|
|||
message.Extensions = append(message.Extensions, extensions.NewReplyFallback(reply.Start, reply.End))
|
||||
}
|
||||
}
|
||||
if marker != nil {
|
||||
if marker.Type == MarkerTypeReceived {
|
||||
message.Extensions = append(message.Extensions, stanza.MarkReceived{ID: marker.Id})
|
||||
} else if marker.Type == MarkerTypeDisplayed {
|
||||
message.Extensions = append(message.Extensions, stanza.MarkDisplayed{ID: marker.Id})
|
||||
message.Extensions = append(message.Extensions, stanza.ReceiptReceived{ID: marker.Id})
|
||||
}
|
||||
}
|
||||
if !isCarbon && toJid.Resource != "" {
|
||||
message.Extensions = append(message.Extensions, stanza.HintNoCopy{})
|
||||
}
|
||||
if requestReceipt {
|
||||
message.Extensions = append(message.Extensions, stanza.Markable{})
|
||||
}
|
||||
if replaceId != "" {
|
||||
message.Extensions = append(message.Extensions, extensions.Replace{Id: replaceId})
|
||||
if nick != "" {
|
||||
message.Extensions = append(message.Extensions, extensions.NickExtension{
|
||||
Text: nick,
|
||||
})
|
||||
}
|
||||
|
||||
if isCarbon {
|
||||
if isOutgoing {
|
||||
carbonMessage := extensions.ClientMessage{
|
||||
Attrs: stanza.Attrs{
|
||||
From: bareTo,
|
||||
|
|
@ -186,19 +144,11 @@ func sendMessageWrapper(to string, from string, body string, id string, componen
|
|||
To: toJid.Domain,
|
||||
},
|
||||
}
|
||||
if MessageOutgoingPermissionVersion == 2 {
|
||||
privilegeMessage.Extensions = append(privilegeMessage.Extensions, extensions.ComponentPrivilege2{
|
||||
Forwarded: stanza.Forwarded{
|
||||
Stanza: carbonMessage,
|
||||
},
|
||||
})
|
||||
} else {
|
||||
privilegeMessage.Extensions = append(privilegeMessage.Extensions, extensions.ComponentPrivilege1{
|
||||
Forwarded: stanza.Forwarded{
|
||||
Stanza: carbonMessage,
|
||||
},
|
||||
})
|
||||
}
|
||||
privilegeMessage.Extensions = append(privilegeMessage.Extensions, extensions.ComponentPrivilege{
|
||||
Forwarded: stanza.Forwarded{
|
||||
Stanza: carbonMessage,
|
||||
},
|
||||
})
|
||||
sendMessage(&privilegeMessage, component)
|
||||
} else {
|
||||
sendMessage(&message, component)
|
||||
|
|
@ -324,7 +274,7 @@ func newPresence(bareJid string, to string, args ...args.V) stanza.Presence {
|
|||
if SPNickname.IsSet(args) {
|
||||
nickname := SPNickname.Get(args)
|
||||
if nickname != "" {
|
||||
presence.Extensions = append(presence.Extensions, extensions.PresenceNickExtension{
|
||||
presence.Extensions = append(presence.Extensions, extensions.NickExtension{
|
||||
Text: nickname,
|
||||
})
|
||||
}
|
||||
|
|
@ -387,20 +337,6 @@ func SendPresence(component *xmpp.Component, to string, args ...args.V) error {
|
|||
return nil
|
||||
}
|
||||
|
||||
// SPAppendFrom appends numeric from and resource to varargs
|
||||
func SPAppendFrom(oldArgs []args.V, id int64) []args.V {
|
||||
newArgs := append(oldArgs, SPFrom(strconv.FormatInt(id, 10)))
|
||||
newArgs = append(newArgs, SPResource(Jid.Resource))
|
||||
return newArgs
|
||||
}
|
||||
|
||||
// SimplePresence crafts simple presence varargs
|
||||
func SimplePresence(from int64, typ string) []args.V {
|
||||
args := []args.V{SPType(typ)}
|
||||
args = SPAppendFrom(args, from)
|
||||
return args
|
||||
}
|
||||
|
||||
// ResumableSend tries to resume the connection once and sends the packet again
|
||||
func ResumableSend(component *xmpp.Component, packet stanza.Packet) error {
|
||||
err := component.Send(packet)
|
||||
|
|
@ -418,12 +354,6 @@ func ResumableSend(component *xmpp.Component, packet stanza.Packet) error {
|
|||
return err
|
||||
}
|
||||
|
||||
// SubscribeToTransport ensures a two-way subscription to the transport
|
||||
func SubscribeToTransport(component *xmpp.Component, jid string) {
|
||||
SendPresence(component, jid, SPType("subscribe"))
|
||||
SendPresence(component, jid, SPType("subscribed"))
|
||||
}
|
||||
|
||||
// SplitJID tokenizes a JID string to bare JID and resource
|
||||
func SplitJID(from string) (string, string, bool) {
|
||||
fromJid, err := stanza.NewJid(from)
|
||||
|
|
|
|||
289
xmpp/handlers.go
289
xmpp/handlers.go
|
|
@ -4,7 +4,6 @@ import (
|
|||
"bytes"
|
||||
"encoding/base64"
|
||||
"encoding/xml"
|
||||
"fmt"
|
||||
"github.com/pkg/errors"
|
||||
"io"
|
||||
"strconv"
|
||||
|
|
@ -16,7 +15,6 @@ import (
|
|||
"dev.narayana.im/narayana/telegabber/xmpp/gateway"
|
||||
|
||||
log "github.com/sirupsen/logrus"
|
||||
"github.com/soheilhy/args"
|
||||
"gosrc.io/xmpp"
|
||||
"gosrc.io/xmpp/stanza"
|
||||
)
|
||||
|
|
@ -58,22 +56,6 @@ func HandleIq(s xmpp.Sender, p stanza.Packet) {
|
|||
go handleGetDiscoInfo(s, iq)
|
||||
return
|
||||
}
|
||||
_, ok = iq.Payload.(*stanza.DiscoItems)
|
||||
if ok {
|
||||
go handleGetDiscoItems(s, iq)
|
||||
return
|
||||
}
|
||||
_, ok = iq.Payload.(*extensions.QueryRegister)
|
||||
if ok {
|
||||
go handleGetQueryRegister(s, iq)
|
||||
return
|
||||
}
|
||||
} else if iq.Type == "set" {
|
||||
query, ok := iq.Payload.(*extensions.QueryRegister)
|
||||
if ok {
|
||||
go handleSetQueryRegister(s, iq, query)
|
||||
return
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -108,7 +90,8 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
|
|||
session, ok := sessions[bare]
|
||||
if !ok {
|
||||
if msg.To == gatewayJid {
|
||||
gateway.SubscribeToTransport(component, msg.From)
|
||||
gateway.SendPresence(component, msg.From, gateway.SPType("subscribe"))
|
||||
gateway.SendPresence(component, msg.From, gateway.SPType("subscribed"))
|
||||
} else {
|
||||
log.Error("Message from stranger")
|
||||
}
|
||||
|
|
@ -165,12 +148,7 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
|
|||
"end": body.End,
|
||||
}).Warn(errors.Wrap(err, "Failed to parse fallback end!"))
|
||||
}
|
||||
|
||||
fullRunes := []rune(text)
|
||||
cutRunes := make([]rune, 0, len(text)-int(end-start))
|
||||
cutRunes = append(cutRunes, fullRunes[:start]...)
|
||||
cutRunes = append(cutRunes, fullRunes[end:]...)
|
||||
text = string(cutRunes)
|
||||
text = text[:start] + text[end:]
|
||||
}
|
||||
}
|
||||
var replaceId int64
|
||||
|
|
@ -189,8 +167,6 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
|
|||
}
|
||||
}
|
||||
|
||||
session.SendMessageLock.Lock()
|
||||
defer session.SendMessageLock.Unlock()
|
||||
tgMessageId := session.ProcessOutgoingMessage(toID, text, msg.From, replyId, replaceId)
|
||||
if tgMessageId != 0 {
|
||||
if replaceId != 0 {
|
||||
|
|
@ -199,13 +175,9 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
|
|||
if err != nil {
|
||||
log.Errorf("Failed to replace id %v with %v %v", replace.Id, msg.Id, tgMessageId)
|
||||
} */
|
||||
session.AddToEditOutbox(replace.Id, resource)
|
||||
} else {
|
||||
err = gateway.IdsDB.Set(session.Session.Login, bare, toID, tgMessageId, msg.Id)
|
||||
if err == nil {
|
||||
// session.AddToOutbox(msg.Id, resource)
|
||||
session.UpdateLastChatMessageId(toID, msg.Id)
|
||||
} else {
|
||||
if err != nil {
|
||||
log.Errorf("Failed to save ids %v/%v %v", toID, tgMessageId, msg.Id)
|
||||
}
|
||||
}
|
||||
|
|
@ -234,51 +206,16 @@ func HandleMessage(s xmpp.Sender, p stanza.Packet) {
|
|||
}
|
||||
|
||||
if msg.Body == "" {
|
||||
var privilege1 extensions.ComponentPrivilege1
|
||||
if ok := msg.Get(&privilege1); ok {
|
||||
log.Debugf("privilege1: %#v", privilege1)
|
||||
var privilege extensions.ComponentPrivilege
|
||||
if ok := msg.Get(&privilege); ok {
|
||||
log.Debugf("privilege: %#v", privilege)
|
||||
}
|
||||
|
||||
for _, perm := range privilege1.Perms {
|
||||
for _, perm := range privilege.Perms {
|
||||
if perm.Access == "message" && perm.Type == "outgoing" {
|
||||
gateway.MessageOutgoingPermissionVersion = 1
|
||||
gateway.MessageOutgoingPermission = true
|
||||
}
|
||||
}
|
||||
|
||||
var privilege2 extensions.ComponentPrivilege2
|
||||
if ok := msg.Get(&privilege2); ok {
|
||||
log.Debugf("privilege2: %#v", privilege2)
|
||||
}
|
||||
|
||||
for _, perm := range privilege2.Perms {
|
||||
if perm.Access == "message" && perm.Type == "outgoing" {
|
||||
gateway.MessageOutgoingPermissionVersion = 2
|
||||
}
|
||||
}
|
||||
|
||||
var displayed stanza.MarkDisplayed
|
||||
msg.Get(&displayed)
|
||||
if displayed.ID != "" {
|
||||
log.Debugf("displayed: %#v", displayed)
|
||||
|
||||
bare, _, ok := gateway.SplitJID(msg.From)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
session, ok := sessions[bare]
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
toID, ok := toToID(msg.To)
|
||||
if !ok {
|
||||
return
|
||||
}
|
||||
msgId, err := strconv.ParseInt(displayed.ID, 10, 64)
|
||||
if err == nil {
|
||||
session.MarkAsRead(toID, msgId)
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if msg.Type == "error" {
|
||||
|
|
@ -398,21 +335,13 @@ func handlePresence(s xmpp.Sender, p stanza.Presence) {
|
|||
log.Error(errors.Wrap(err, "TDlib connection failure"))
|
||||
} else {
|
||||
for status := range session.StatusesRange() {
|
||||
show, description, typ := status.Destruct()
|
||||
newArgs := []args.V{
|
||||
gateway.SPImmed(false),
|
||||
}
|
||||
if typ != "" {
|
||||
newArgs = append(newArgs, gateway.SPType(typ))
|
||||
}
|
||||
go session.ProcessStatusUpdate(
|
||||
status.ID,
|
||||
description,
|
||||
show,
|
||||
newArgs...,
|
||||
status.Description,
|
||||
status.XMPP,
|
||||
gateway.SPImmed(false),
|
||||
)
|
||||
}
|
||||
session.UpdateChatNicknames()
|
||||
}
|
||||
}()
|
||||
}
|
||||
|
|
@ -485,11 +414,8 @@ func handleGetDiscoInfo(s xmpp.Sender, iq *stanza.IQ) {
|
|||
_, ok := toToID(iq.To)
|
||||
if ok {
|
||||
disco.AddIdentity("", "account", "registered")
|
||||
disco.AddFeatures(stanza.NSMsgChatMarkers)
|
||||
disco.AddFeatures(stanza.NSMsgReceipts)
|
||||
} else {
|
||||
disco.AddIdentity("Telegram Gateway", "gateway", "telegram")
|
||||
disco.AddFeatures("jabber:iq:register")
|
||||
}
|
||||
answer.Payload = disco
|
||||
|
||||
|
|
@ -504,189 +430,6 @@ func handleGetDiscoInfo(s xmpp.Sender, iq *stanza.IQ) {
|
|||
_ = gateway.ResumableSend(component, answer)
|
||||
}
|
||||
|
||||
func handleGetDiscoItems(s xmpp.Sender, iq *stanza.IQ) {
|
||||
answer, err := stanza.NewIQ(stanza.Attrs{
|
||||
Type: stanza.IQTypeResult,
|
||||
From: iq.To,
|
||||
To: iq.From,
|
||||
Id: iq.Id,
|
||||
Lang: "en",
|
||||
})
|
||||
if err != nil {
|
||||
log.Errorf("Failed to create answer IQ: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
answer.Payload = answer.DiscoItems()
|
||||
|
||||
component, ok := s.(*xmpp.Component)
|
||||
if !ok {
|
||||
log.Error("Not a component")
|
||||
return
|
||||
}
|
||||
|
||||
_ = gateway.ResumableSend(component, answer)
|
||||
}
|
||||
|
||||
func handleGetQueryRegister(s xmpp.Sender, iq *stanza.IQ) {
|
||||
component, ok := s.(*xmpp.Component)
|
||||
if !ok {
|
||||
log.Error("Not a component")
|
||||
return
|
||||
}
|
||||
|
||||
answer, err := stanza.NewIQ(stanza.Attrs{
|
||||
Type: stanza.IQTypeResult,
|
||||
From: iq.To,
|
||||
To: iq.From,
|
||||
Id: iq.Id,
|
||||
Lang: "en",
|
||||
})
|
||||
if err != nil {
|
||||
log.Errorf("Failed to create answer IQ: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
var login string
|
||||
bare, _, ok := gateway.SplitJID(iq.From)
|
||||
if ok {
|
||||
session, ok := sessions[bare]
|
||||
if ok {
|
||||
login = session.Session.Login
|
||||
}
|
||||
}
|
||||
|
||||
var query stanza.IQPayload
|
||||
if login == "" {
|
||||
query = extensions.QueryRegister{
|
||||
Instructions: fmt.Sprintf("Authorization in Telegram is a multi-step process, so please accept %v to your contacts and follow further instructions (provide the authentication code there, etc.).\nFor now, please provide your login.", iq.To),
|
||||
}
|
||||
} else {
|
||||
query = extensions.QueryRegister{
|
||||
Instructions: "Already logged in",
|
||||
Username: login,
|
||||
Registered: &extensions.QueryRegisterRegistered{},
|
||||
}
|
||||
}
|
||||
answer.Payload = query
|
||||
|
||||
log.Debugf("%#v", query)
|
||||
|
||||
_ = gateway.ResumableSend(component, answer)
|
||||
|
||||
if login == "" {
|
||||
gateway.SubscribeToTransport(component, iq.From)
|
||||
}
|
||||
}
|
||||
|
||||
func handleSetQueryRegister(s xmpp.Sender, iq *stanza.IQ, query *extensions.QueryRegister) {
|
||||
component, ok := s.(*xmpp.Component)
|
||||
if !ok {
|
||||
log.Error("Not a component")
|
||||
return
|
||||
}
|
||||
|
||||
answer, err := stanza.NewIQ(stanza.Attrs{
|
||||
Type: stanza.IQTypeResult,
|
||||
From: iq.To,
|
||||
To: iq.From,
|
||||
Id: iq.Id,
|
||||
Lang: "en",
|
||||
})
|
||||
if err != nil {
|
||||
log.Errorf("Failed to create answer IQ: %v", err)
|
||||
return
|
||||
}
|
||||
|
||||
defer gateway.ResumableSend(component, answer)
|
||||
|
||||
if query.Remove != nil {
|
||||
iqAnswerSetError(answer, query, 405)
|
||||
return
|
||||
}
|
||||
|
||||
var login string
|
||||
var session *telegram.Client
|
||||
bare, resource, ok := gateway.SplitJID(iq.From)
|
||||
if ok {
|
||||
session, ok = sessions[bare]
|
||||
if ok {
|
||||
login = session.Session.Login
|
||||
}
|
||||
}
|
||||
|
||||
if login == "" {
|
||||
if !ok {
|
||||
session, ok = getTelegramInstance(bare, &persistence.Session{}, component)
|
||||
if !ok {
|
||||
iqAnswerSetError(answer, query, 500)
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
err := session.TryLogin(resource, query.Username)
|
||||
if err != nil {
|
||||
if err.Error() == telegram.TelegramAuthDone {
|
||||
iqAnswerSetError(answer, query, 406)
|
||||
} else {
|
||||
iqAnswerSetError(answer, query, 500)
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
err = session.SetPhoneNumber(query.Username)
|
||||
if err != nil {
|
||||
iqAnswerSetError(answer, query, 500)
|
||||
return
|
||||
}
|
||||
|
||||
// everything okay, the response should be empty with no payload/error at this point
|
||||
gateway.SubscribeToTransport(component, iq.From)
|
||||
} else {
|
||||
iqAnswerSetError(answer, query, 406)
|
||||
}
|
||||
}
|
||||
|
||||
func iqAnswerSetError(answer *stanza.IQ, payload *extensions.QueryRegister, code int) {
|
||||
answer.Type = stanza.IQTypeError
|
||||
answer.Payload = *payload
|
||||
switch code {
|
||||
case 400:
|
||||
answer.Error = &stanza.Err{
|
||||
Code: code,
|
||||
Type: stanza.ErrorTypeModify,
|
||||
Reason: "bad-request",
|
||||
}
|
||||
case 405:
|
||||
answer.Error = &stanza.Err{
|
||||
Code: code,
|
||||
Type: stanza.ErrorTypeCancel,
|
||||
Reason: "not-allowed",
|
||||
Text: "Logging out is dangerous. If you are sure you would be able to receive the authentication code again, issue the /logout command to the transport",
|
||||
}
|
||||
case 406:
|
||||
answer.Error = &stanza.Err{
|
||||
Code: code,
|
||||
Type: stanza.ErrorTypeModify,
|
||||
Reason: "not-acceptable",
|
||||
Text: "Phone number already provided, chat with the transport for further instruction",
|
||||
}
|
||||
case 500:
|
||||
answer.Error = &stanza.Err{
|
||||
Code: code,
|
||||
Type: stanza.ErrorTypeWait,
|
||||
Reason: "internal-server-error",
|
||||
}
|
||||
default:
|
||||
log.Error("Unknown error code, falling back with empty reason")
|
||||
answer.Error = &stanza.Err{
|
||||
Code: code,
|
||||
Type: stanza.ErrorTypeCancel,
|
||||
Reason: "undefined-condition",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func toToID(to string) (int64, bool) {
|
||||
toParts := strings.Split(to, "@")
|
||||
if len(toParts) < 2 {
|
||||
|
|
@ -733,7 +476,7 @@ func makeVCardPayload(typ byte, id string, info telegram.VCardInfo, session *tel
|
|||
vcard.Photo.Type.Text = "image/jpeg"
|
||||
vcard.Photo.Binval.Text = base64Photo
|
||||
}
|
||||
vcard.Nickname.Text = strings.Join(info.Nicknames, ",")
|
||||
vcard.Nickname.Text = info.Nickname
|
||||
vcard.N.Given.Text = info.Given
|
||||
vcard.N.Family.Text = info.Family
|
||||
vcard.Tel.Number.Text = info.Tel
|
||||
|
|
@ -764,13 +507,13 @@ func makeVCardPayload(typ byte, id string, info telegram.VCardInfo, session *tel
|
|||
},
|
||||
})
|
||||
}
|
||||
for _, nickname := range info.Nicknames {
|
||||
if info.Nickname != "" {
|
||||
nodes = append(nodes, stanza.Node{
|
||||
XMLName: xml.Name{Local: "nickname"},
|
||||
Nodes: []stanza.Node{
|
||||
stanza.Node{
|
||||
XMLName: xml.Name{Local: "text"},
|
||||
Content: nickname,
|
||||
Content: info.Nickname,
|
||||
},
|
||||
},
|
||||
}, stanza.Node{
|
||||
|
|
@ -778,7 +521,7 @@ func makeVCardPayload(typ byte, id string, info telegram.VCardInfo, session *tel
|
|||
Nodes: []stanza.Node{
|
||||
stanza.Node{
|
||||
XMLName: xml.Name{Local: "uri"},
|
||||
Content: "https://t.me/" + nickname,
|
||||
Content: "https://t.me/" + info.Nickname,
|
||||
},
|
||||
},
|
||||
})
|
||||
|
|
|
|||
Loading…
Reference in a new issue