223 lines
7.3 KiB
Go
223 lines
7.3 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"html"
|
|
"regexp"
|
|
"strings"
|
|
|
|
skypeExt "github.com/kelaresg/matrix-skype/skype-ext"
|
|
|
|
"maunium.net/go/mautrix/event"
|
|
"maunium.net/go/mautrix/format"
|
|
"maunium.net/go/mautrix/id"
|
|
|
|
"github.com/kelaresg/matrix-skype/types"
|
|
)
|
|
|
|
var italicRegex = regexp.MustCompile("([\\s>~*]|^)_(.+?)_([^a-zA-Z\\d]|$)")
|
|
var boldRegex = regexp.MustCompile("([\\s>_~]|^)\\*(.+?)\\*([^a-zA-Z\\d]|$)")
|
|
var strikethroughRegex = regexp.MustCompile("([\\s>_*]|^)~(.+?)~([^a-zA-Z\\d]|$)")
|
|
var codeBlockRegex = regexp.MustCompile("```(?:.|\n)+?```")
|
|
|
|
//var mentionRegex = regexp.MustCompile("@[0-9]+")
|
|
//var mentionRegex = regexp.MustCompile("@(.*)")
|
|
var mentionRegex = regexp.MustCompile("<at[^>]+\\bid=\"([^\"]+)\"(.*?)</at>*")
|
|
|
|
type Formatter struct {
|
|
bridge *Bridge
|
|
|
|
matrixHTMLParser *format.HTMLParser
|
|
|
|
waReplString map[*regexp.Regexp]string
|
|
waReplFunc map[*regexp.Regexp]func(string) string
|
|
waReplFuncText map[*regexp.Regexp]func(string) string
|
|
}
|
|
|
|
func NewFormatter(bridge *Bridge) *Formatter {
|
|
formatter := &Formatter{
|
|
bridge: bridge,
|
|
matrixHTMLParser: &format.HTMLParser{
|
|
TabsToSpaces: 4,
|
|
Newline: "\n",
|
|
|
|
PillConverter: func(displayname, mxid, eventID string, ctx format.Context) string {
|
|
if mxid[0] == '@' {
|
|
puppet := bridge.GetPuppetByMXID(id.UserID(mxid))
|
|
if puppet != nil {
|
|
return "@" + puppet.PhoneNumber()
|
|
}
|
|
}
|
|
return mxid
|
|
},
|
|
BoldConverter: func(text string, _ format.Context) string {
|
|
return fmt.Sprintf("*%s*", text)
|
|
},
|
|
ItalicConverter: func(text string, _ format.Context) string {
|
|
return fmt.Sprintf("_%s_", text)
|
|
},
|
|
StrikethroughConverter: func(text string, _ format.Context) string {
|
|
return fmt.Sprintf("~%s~", text)
|
|
},
|
|
MonospaceConverter: func(text string, _ format.Context) string {
|
|
return fmt.Sprintf("```%s```", text)
|
|
},
|
|
MonospaceBlockConverter: func(text, language string, _ format.Context) string {
|
|
return fmt.Sprintf("```%s```", text)
|
|
},
|
|
},
|
|
waReplString: map[*regexp.Regexp]string{
|
|
italicRegex: "$1<em>$2</em>$3",
|
|
boldRegex: "$1<strong>$2</strong>$3",
|
|
strikethroughRegex: "$1<del>$2</del>$3",
|
|
},
|
|
}
|
|
formatter.waReplFunc = map[*regexp.Regexp]func(string) string{
|
|
codeBlockRegex: func(str string) string {
|
|
str = str[3 : len(str)-3]
|
|
if strings.ContainsRune(str, '\n') {
|
|
return fmt.Sprintf("<pre><code>%s</code></pre>", str)
|
|
}
|
|
return fmt.Sprintf("<code>%s</code>", str)
|
|
},
|
|
}
|
|
formatter.waReplFuncText = map[*regexp.Regexp]func(string) string{
|
|
}
|
|
return formatter
|
|
}
|
|
|
|
func (formatter *Formatter) getMatrixInfoByJID(jid types.SkypeID) (mxid id.UserID, displayname string) {
|
|
if user := formatter.bridge.GetUserByJID(jid); user != nil {
|
|
mxid = user.MXID
|
|
displayname = string(user.MXID)
|
|
} else if puppet := formatter.bridge.GetPuppetByJID(jid); puppet != nil {
|
|
mxid = puppet.MXID
|
|
displayname = puppet.Displayname
|
|
}
|
|
return
|
|
}
|
|
|
|
func (formatter *Formatter) ParseSkype(content *event.MessageEventContent, RoomMXID id.RoomID) {
|
|
// parse '<a><a/>' tag
|
|
reg:= regexp.MustCompile(`(?U)(<a .*>(.*)</a>)`)
|
|
bodyMatch := reg.FindAllStringSubmatch(content.Body, -1)
|
|
for _, match := range bodyMatch {
|
|
content.Body = strings.ReplaceAll(content.Body, match[1], match[2])
|
|
}
|
|
|
|
output := content.Body
|
|
for regex, replacement := range formatter.waReplString {
|
|
output = regex.ReplaceAllString(output, replacement)
|
|
}
|
|
for regex, replacer := range formatter.waReplFunc {
|
|
output = regex.ReplaceAllStringFunc(output, replacer)
|
|
}
|
|
content.Body = html.UnescapeString(content.Body)
|
|
|
|
var backStr string
|
|
if output != content.Body {
|
|
output = strings.Replace(output, "\n", "<br/>", -1)
|
|
content.FormattedBody = output
|
|
content.Format = event.FormatHTML
|
|
var mxid id.UserID
|
|
|
|
// parse quote message(set reply)
|
|
content.Body = strings.ReplaceAll(content.Body, "\n", "")
|
|
quoteReg := regexp.MustCompile(`<quote[^>]+\bauthor="([^"]+)" authorname="([^"]+)" timestamp="([^"]+)" conversation="([^"]+)" messageid="([^"]+)".*>.*?</legacyquote>(.*?)<legacyquote>.*?</legacyquote></quote>(.*)`)
|
|
quoteMatches := quoteReg.FindAllStringSubmatch(content.Body, -1)
|
|
|
|
if len(quoteMatches) > 0 {
|
|
for _, match := range quoteMatches {
|
|
for index, a := range match {
|
|
fmt.Println("index: ", index)
|
|
fmt.Println("ParseSkype quoteMatches a:", a)
|
|
fmt.Println()
|
|
}
|
|
portal := formatter.bridge.GetPortalByMXID(RoomMXID)
|
|
if portal.Key.JID != match[4] {
|
|
content.FormattedBody = match[6]
|
|
content.Body = fmt.Sprintf("%s\n\n", match[6])
|
|
|
|
// this means that there are forwarding messages across groups
|
|
if strings.HasSuffix(match[4], skypeExt.GroupSuffix) || strings.HasSuffix(portal.Key.JID, skypeExt.GroupSuffix){
|
|
continue
|
|
}
|
|
}
|
|
msgMXID := ""
|
|
msg := formatter.bridge.DB.Message.GetByID(match[5])
|
|
if msg != nil {
|
|
msgMXID = string(msg.MXID)
|
|
}
|
|
mxid, _ = formatter.getMatrixInfoByJID("8:" + match[1] + skypeExt.NewUserSuffix)
|
|
href1 := fmt.Sprintf(`https://%s/#/room/%s/%s?via=%s`, formatter.bridge.Config.Homeserver.ServerName, RoomMXID, msgMXID, formatter.bridge.Config.Homeserver.Domain)
|
|
href2 := fmt.Sprintf(`https://%s/#/user/%s`, formatter.bridge.Config.Homeserver.ServerName, mxid)
|
|
newContent := fmt.Sprintf(`<mx-reply><blockquote><a href="%s">In reply to</a> <a href="%s">%s</a><br>%s</blockquote></mx-reply>`,
|
|
href1,
|
|
href2,
|
|
mxid,
|
|
match[6])
|
|
content.FormattedBody = newContent
|
|
content.Body = fmt.Sprintf("> <%s> %s\n\n", mxid, match[6])
|
|
inRelateTo := &event.RelatesTo{
|
|
Type: event.RelReply,
|
|
EventID: id.EventID(msgMXID),
|
|
}
|
|
content.SetRelatesTo(inRelateTo)
|
|
backStr = match[7]
|
|
}
|
|
}
|
|
}
|
|
|
|
// parse mention user message
|
|
r := regexp.MustCompile(`(?m)<at[^>]+\bid="([^"]+)">(.*?)</at>`)
|
|
var originStr string
|
|
var originBodyStr string
|
|
if len(backStr) == 0 {
|
|
originStr = content.Body
|
|
} else {
|
|
originStr = backStr
|
|
}
|
|
matches := r.FindAllStringSubmatch(originStr, -1)
|
|
if len(matches) > 0 {
|
|
for _, match := range matches {
|
|
mxid, displayname := formatter.getMatrixInfoByJID(match[1] + skypeExt.NewUserSuffix)
|
|
replaceStr := ""
|
|
if len(displayname) < 1 {
|
|
// TODO need to optimize
|
|
replaceStr = match[2] + ":"
|
|
} else {
|
|
replaceStr = fmt.Sprintf(`<a href="https://%s/#/%s">%s</a>:`, formatter.bridge.Config.Homeserver.ServerName, mxid, displayname)
|
|
}
|
|
// number := "@" + strings.Replace(match[1], skypeExt.NewUserSuffix, "", 1)
|
|
originStr = strings.ReplaceAll(originStr, match[0], replaceStr)
|
|
originBodyStr = strings.ReplaceAll(originStr, replaceStr, displayname + ":")
|
|
}
|
|
if len(backStr) == 0 {
|
|
content.Format = event.FormatHTML
|
|
content.Body = originBodyStr
|
|
content.FormattedBody = originStr
|
|
} else {
|
|
content.Body = content.Body + originBodyStr
|
|
content.FormattedBody = content.FormattedBody + originStr
|
|
}
|
|
} else {
|
|
content.Body = content.Body + backStr
|
|
content.FormattedBody = content.FormattedBody + backStr
|
|
}
|
|
|
|
//filter edit tag
|
|
e := regexp.MustCompile(`(<e_m a=".*></e_m>)`)
|
|
editMatches := e.FindAllStringSubmatch(content.Body, -1)
|
|
if len(editMatches) > 0 {
|
|
for _, match := range editMatches {
|
|
content.Body = strings.ReplaceAll(content.Body, match[0], "")
|
|
content.FormattedBody = strings.ReplaceAll(content.FormattedBody, match[0], "")
|
|
}
|
|
}
|
|
}
|
|
|
|
func (formatter *Formatter) ParseMatrix(html string) string {
|
|
ctx := make(format.Context)
|
|
return formatter.matrixHTMLParser.Parse(html, ctx)
|
|
}
|