func httpIndexHandler(w http.ResponseWriter, r *http.Request) {
foo := foo{Foo: "Blaat"}
if r.FormValue("queueId") != "" {
http.Redirect(w, r, "/message/"+r.FormValue("queueId"), http.StatusFound)
return
}
if r.FormValue("mailAddress") != "" {
http.Redirect(w, r, "/message/searchEmail/"+r.FormValue("mailAddress"), http.StatusFound)
return
}
if r.FormValue("clientAddress") != "" {
http.Redirect(w, r, "/message/searchClientAddress/"+r.FormValue("clientAddress"), http.StatusFound)
return
}
if r.FormValue("saslUser") != "" {
http.Redirect(w, r, "/message/searchSaslUser/"+r.FormValue("saslUser"), http.StatusFound)
return
}
tplIndex, _ := assets.Asset("htmlTemplates/index.html")
tplSkeleton, _ := assets.Asset("htmlTemplates/skeleton.html")
tpl := template.New("skeleton.html")
tpl.Parse(string(tplIndex))
tpl.Parse(string(tplSkeleton))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := tpl.ExecuteTemplate(w, "skeleton.html", foo); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
func httpProcessSearchResultRows(w http.ResponseWriter, r *http.Request, rows *sql.Rows) {
messages := make([]*httpMessage, 0)
for rows.Next() {
message := &httpMessage{Recipients: make([]*httpMessageRecipient, 0)}
var rcptsStr string
rows.Scan(&message.Id, &message.Date, &message.Sender, &message.RcptCount,
&message.Verdict, &rcptsStr)
for _, rcpt := range strings.Split(rcptsStr, ",") {
message.Recipients = append(message.Recipients, &httpMessageRecipient{Email: rcpt})
}
messages = append(messages, message)
}
if r.FormValue("json") == "1" {
httpReturnJson(w, messages)
return
}
tplMsgSearchEmail, _ := assets.Asset("htmlTemplates/messageSearchEmail.html")
tplSkeleton, _ := assets.Asset("htmlTemplates/skeleton.html")
tpl := template.New("skeleton.html")
tpl.Parse(string(tplMsgSearchEmail))
tpl.Parse(string(tplSkeleton))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := tpl.ExecuteTemplate(w, "skeleton.html", messages); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
func httpStatsHandler(w http.ResponseWriter, r *http.Request) {
foo := foo{Foo: "Blaat"}
tplStats, _ := assets.Asset("htmlTemplates/stats.html")
tplSkeleton, _ := assets.Asset("htmlTemplates/skeleton.html")
tpl := template.New("skeleton.html")
tpl.Parse(string(tplStats))
tpl.Parse(string(tplSkeleton))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := tpl.ExecuteTemplate(w, "skeleton.html", foo); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
func httpRenderOutput(w http.ResponseWriter, r *http.Request, templateFile string, data, jsonData interface{}) {
if r.FormValue("json") == "1" {
if jsonData == nil {
http.Error(w, "No parameter 'json' supported", http.StatusBadRequest)
return
}
httpReturnJson(w, jsonData)
return
}
tplPage, _ := assets.Asset("htmlTemplates/" + templateFile)
tplSkeleton, _ := assets.Asset("htmlTemplates/skeleton.html")
tpl := template.New("skeleton.html")
tpl.Parse(string(tplPage))
tpl.Parse(string(tplSkeleton))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := tpl.ExecuteTemplate(w, "skeleton.html", data); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
func httpHandlerMessage(w http.ResponseWriter, r *http.Request) {
queueId := r.URL.Path[len("/message/"):]
row := Rdbms.QueryRow(`
SELECT m.session, m.date, coalesce(m.body_size,0), m.sender_local || '@' || m.sender_domain sender,
m.rcpt_count, m.verdict, m.verdict_msg,
COALESCE(m.rejectScore,0), COALESCE(m.rejectScoreThreshold,0), COALESCE(m.tempfailScore,0),
(COALESCE(m.rejectScore,0) + COALESCE(m.tempfailScore,0)) scoreCombined,
COALESCE(m.tempfailScoreThreshold,0), s.ip, s.reverse_dns, s.sasl_username, s.sasl_method,
s.cert_issuer, s.cert_subject, s.cipher_bits, s.cipher, s.tls_version,
cc.hostname mtaHostname, cc.daemon_name mtaDaemonName
FROM message m
LEFT JOIN session s ON s.id = m.session
LEFT JOIN cluegetter_client cc on s.cluegetter_client = cc.id
WHERE m.id = ?`, queueId)
msg := &httpMessage{Recipients: make([]*httpMessageRecipient, 0)}
row.Scan(&msg.SessionId, &msg.Date, &msg.BodySize, &msg.Sender, &msg.RcptCount,
&msg.Verdict, &msg.VerdictMsg, &msg.RejectScore, &msg.RejectScoreThreshold,
&msg.TempfailScore, &msg.ScoreCombined, &msg.TempfailScoreThreshold,
&msg.Ip, &msg.ReverseDns, &msg.SaslUsername, &msg.SaslMethod,
&msg.CertIssuer, &msg.CertSubject, &msg.CipherBits, &msg.Cipher, &msg.TlsVersion,
&msg.MtaHostname, &msg.MtaDaemonName)
msg.BodySizeStr = humanize.Bytes(uint64(msg.BodySize))
recipientRows, _ := Rdbms.Query(
"SELECT r.id, r.local, r.domain FROM recipient r "+
"LEFT JOIN message_recipient mr ON mr.recipient = r.id "+
"LEFT JOIN message m ON m.id = mr.message WHERE message = ?", queueId)
defer recipientRows.Close()
for recipientRows.Next() {
recipient := &httpMessageRecipient{}
recipientRows.Scan(&recipient.Id, &recipient.Local, &recipient.Domain)
if recipient.Domain == "" {
recipient.Email = recipient.Local
} else {
recipient.Email = recipient.Local + "@" + recipient.Domain
}
msg.Recipients = append(msg.Recipients, recipient)
}
headerRows, _ := Rdbms.Query("SELECT name, body FROM message_header WHERE message = ?", queueId)
defer headerRows.Close()
for headerRows.Next() {
header := &httpMessageHeader{}
headerRows.Scan(&header.Name, &header.Body)
msg.Headers = append(msg.Headers, header)
}
checkResultRows, _ := Rdbms.Query(
`SELECT module, verdict, score, weighted_score, COALESCE(duration, 0.0),
determinants FROM message_result WHERE message = ?`, queueId)
defer checkResultRows.Close()
for checkResultRows.Next() {
checkResult := &httpMessageCheckResult{}
checkResultRows.Scan(&checkResult.Module, &checkResult.Verdict, &checkResult.Score,
&checkResult.WeightedScore, &checkResult.Duration, &checkResult.Determinants)
msg.CheckResults = append(msg.CheckResults, checkResult)
}
if r.FormValue("json") == "1" {
httpReturnJson(w, msg)
return
}
tplSkeleton, _ := assets.Asset("htmlTemplates/skeleton.html")
tplMsg, _ := assets.Asset("htmlTemplates/message.html")
tpl := template.New("skeleton.html")
tpl.Parse(string(tplMsg))
tpl.Parse(string(tplSkeleton))
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := tpl.ExecuteTemplate(w, "skeleton.html", msg); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
}
}
