func getDeviceList(w rest.ResponseWriter, r *rest.Request) {
stats.QueryOnlineDevices()
devInfoList := []devInfo{}
r.ParseForm()
dev_ids := r.FormValue("dev_ids")
if dev_ids != "" {
ids := strings.Split(dev_ids, ",")
for _, id := range ids {
if serverName, err := storage.Instance.CheckDevice(id); err == nil && serverName != "" {
info := devInfo{
Id: id,
}
devInfoList = append(devInfoList, info)
}
}
} else {
rest.Error(w, "Missing \"dev_ids\"", http.StatusBadRequest)
return
}
resp := cloud.ApiResponse{}
resp.ErrNo = cloud.ERR_NOERROR
resp.Data = devInfoList
w.WriteJson(resp)
}
func get_object__decode_request(res rest.ResponseWriter, req *rest.Request) (string, string, map[string]bool, bool) {
// get CONTENT-TYPE parameter
contentType := req.PathParam("content-type")
if len(contentType) == 0 {
rest.Error(res, "Invalid content type", 400)
return "", "", nil, true
}
// get ID parameter
doc_id := req.PathParam("id")
if len(doc_id) == 0 {
rest.Error(res, "Invalid content ID", 400)
return "", "", nil, true
}
// get PAYLOAD parameters
flags := map[string]bool{
"payload": true,
}
for flag_name, _ := range flags {
if req.Form[flag_name] != nil {
flag_str := req.FormValue(flag_name)
flag, err := strconv.ParseBool(flag_str)
if err != nil {
rest.Error(res, "Invalid query "+flag_name+". "+err.Error(), 400)
return "", "", nil, true
}
flags[flag_name] = flag
}
}
return contentType, doc_id, flags, false
}
func getDevice(w rest.ResponseWriter, r *rest.Request) {
devId := r.PathParam("devid")
r.ParseForm()
token := r.FormValue("token")
if token == "" {
rest.Error(w, "Missing \"token\"", http.StatusBadRequest)
return
}
if !checkAuthz(token, devId) {
log.Warnf("Auth failed. token: %s, device_id: %s", token, devId)
rest.Error(w, "Authorization failed", http.StatusForbidden)
return
}
stats.QueryDeviceInfo()
if serverName, err := storage.Instance.CheckDevice(devId); err == nil && serverName != "" {
resp := cloud.ApiResponse{}
resp.ErrNo = cloud.ERR_NOERROR
resp.Data = devInfo{
Id: devId,
}
w.WriteJson(resp)
} else {
rest.NotFound(w, r)
return
}
}
// POST /files/delete
func FileDelete(w rest.ResponseWriter, r *rest.Request) {
r.ParseForm()
id, _ := strconv.ParseInt(r.FormValue("Id"), 10, 64)
file := database.FindFile(id)
// Delete from DB
database.DeleteFile(file)
w.WriteJson("")
}
// APIDialogIndex is used to get dialogs index
func (i *Impl) APIDialogIndex(w rest.ResponseWriter, r *rest.Request) {
userID := r.PathParam("user_id")
page, err := strconv.Atoi(r.FormValue("page"))
offset := 0
if err == nil {
offset = (page - 1) * 10
}
dialogs := i.GetDialogs(userID, offset)
w.WriteJson(&dialogs)
}
// APIMessageIndex is used to show dialog messages
func (i *Impl) APIMessageIndex(w rest.ResponseWriter, r *rest.Request) {
userID := r.PathParam("user_id")
dialogID, _ := strconv.Atoi(r.PathParam("dialog_id"))
page, err := strconv.Atoi(r.FormValue("page"))
offset := 0
if err == nil {
offset = (page - 1) * 10
}
messages := i.IndexMessages(userID, dialogID, offset)
w.WriteJson(&messages)
}
func authKeyValue(req *rest.Request) (string, bool) {
key := req.FormValue("api_key")
if key != "" {
return key, true
}
key = req.Header.Get("Authorization")
if key == "" {
return "", false
} else {
return key, true
}
}
//获取与id对应的邮件内容
func (email *Email) getEmailContent(w rest.ResponseWriter, r *rest.Request) {
log.Printf("get email content...")
addr := r.FormValue("pop3Addr")
//使用pop3Addr参数区分协议类型
log.Printf("pop3 addr=%s\n", addr)
if addr != "" {
email.getEmailContentUsePop3(w, r)
} else {
email.getEmailContentUseIMAP(w, r)
}
}
// POST /releases/delete
func ReleaseDelete(w rest.ResponseWriter, r *rest.Request) {
r.ParseForm()
id, _ := strconv.ParseInt(r.FormValue("Id"), 10, 64)
release := database.FindRelease(id)
file := database.FindFile(release.FileId)
// Delete from DB
database.DeleteRelease(release)
database.UnpublishFile(file)
go database.RefreshBuilds()
// http.Redirect(w, r, "/admin/releases", http.StatusFound)
w.WriteJson("")
}
func eventData(req *rest.Request, out interface{}) error {
encoded := req.FormValue("data")
if encoded != "" {
if err := decodeData(encoded, &out); err != nil {
return err
} else {
return nil
}
}
if err := req.DecodeJsonPayload(&out); err != nil {
return err
} else {
return nil
}
}
/* GET /email 统一入口，通过参数区分具体的请求 GET /email?pop3Addr=pop.163.com&pop3Port=22&user=myusername&pwd=mypasswords&afterId=*** GET /email?pop3Addr=pop.163.com&pop3Port=22&user=myusername&pwd=mypasswords&id=*** tes url http://localhost:8080/email?pop3Addr=pop.126.com&pop3Port=110&[email protected]&pwd=***&afterId=1 */ func (email *Email) GetEmailListAndContent(w rest.ResponseWriter, r *rest.Request) { log.Printf("enter into get email list and content...") //检验参数是否完整 getListArgs := r.FormValue("afterId") getContentArgs := r.FormValue("id") log.Printf("url query params: afterId=%s, id=%s", getListArgs, getContentArgs) if getListArgs != "" { email.getEmailList(w, r) } else if getContentArgs != "" { email.getEmailContent(w, r) } //回复错误信息 }
func getRouterList(w rest.ResponseWriter, r *rest.Request) {
type RouterInfo struct {
Rid string `json:"rid"`
Rname string `json:"rname"`
}
type ResponseRouterList struct {
Status int `json:"status"`
Descr string `json:"descr"`
List []RouterInfo `json:"list"`
}
resp := ResponseRouterList{}
resp.Status = STATUS_OTHER_ERR
r.ParseForm()
uid := r.FormValue("uid")
if uid == "" {
resp.Status = STATUS_INVALID_PARAM
resp.Descr = "missing 'uid'"
w.WriteJson(resp)
return
}
devices, err := devcenter.GetDevices(uid, devcenter.DEV_ROUTER)
if err != nil {
log.Errorf("GetDevices failed: %s", err.Error())
resp.Descr = err.Error()
w.WriteJson(resp)
return
}
for _, dev := range devices {
router := RouterInfo{
Rid: dev.Id,
Rname: dev.Title,
}
resp.List = append(resp.List, router)
}
resp.Status = 0
resp.Descr = "OK"
w.WriteJson(resp)
}
func getSysStats(w rest.ResponseWriter, r *rest.Request) {
r.ParseForm()
startDate := r.FormValue("start_date")
endDate := r.FormValue("end_date")
var (
start time.Time
end time.Time
err error
)
if startDate == "" {
start = time.Now()
} else {
if start, err = time.Parse("20060102", startDate); err != nil {
rest.Error(w, "invalid date format", http.StatusBadRequest)
return
}
}
if endDate == "" {
end = time.Now()
} else {
if end, err = time.Parse("20060102", endDate); err != nil {
rest.Error(w, "invalid date format", http.StatusBadRequest)
return
}
}
if start.After(end) {
rest.Error(w, "start date greater than end date", http.StatusBadRequest)
return
}
resp := Response{
ErrNo: 0,
}
resp.Data, err = storage.Instance.GetSysStats(start, end)
if err != nil {
rest.Error(w, "storage I/O failed", http.StatusInternalServerError)
log.Warnf("GetSysStats failed: %s", err.Error())
return
}
w.WriteJson(resp)
}
func (email *Email) getEmailListUsePop3(w rest.ResponseWriter, r *rest.Request) ([]EmailHeader, error) {
addr := r.FormValue("pop3Addr")
port := r.FormValue("pop3Port")
user := r.FormValue("user")
pwd := r.FormValue("pwd")
afterId := r.FormValue("afterId")
address := addr + ":" + port
log.Printf("pop3 addr=%s\n", address)
client, err := email.getPop3EmailClient(address, user, pwd)
if err != nil {
return nil, err
}
defer func() {
client.Quit()
client.Close()
}()
var count int
var size uint64
if count, size, err = client.Stat(); err != nil {
log.Printf("Error: %v\n", err)
return nil, err
}
log.Printf("Count: %d, Size: %d\n", count, size)
//获取指定afterid及以后的所有邮件列表
headers := make([]EmailHeader, 0)
id, _ := strconv.Atoi(afterId)
for i := id; i <= count; i++ {
log.Printf("=============")
log.Printf("i=%d, count=%d\n", i, count)
if _, size, err = client.List(i); err != nil {
log.Printf("Error: %v\n", err)
return nil, err
}
log.Printf("email Number: %d, Size: %d\n", i, size)
header := EmailHeader{}
header.Id = strconv.Itoa(i)
headers = append(headers, header)
}
return headers, nil
}
func (email *Email) getEmailContentUsePop3(w rest.ResponseWriter, r *rest.Request) {
addr := r.FormValue("pop3Addr")
port := r.FormValue("pop3Port")
user := r.FormValue("user")
pwd := r.FormValue("pwd")
id := r.FormValue("id")
address := addr + ":" + port
client, err := email.getPop3EmailClient(address, user, pwd)
if err != nil {
errorInfo := ErrorInfo{Code: 403, Name: ""}
resp := EmailJsonResponse{Success: false, Error: errorInfo}
w.WriteJson(&resp)
}
defer func() {
client.Quit()
client.Close()
}()
var body string
content := EmailContent{}
i, _ := strconv.Atoi(id)
if body, err = client.Retr(i); err != nil {
log.Printf("Error: %v\n", err)
errorInfo := ErrorInfo{Code: 403, Name: ""}
resp := EmailJsonResponse{Success: false, Error: errorInfo}
w.WriteJson(&resp)
return
}
_, subject, senderAddr, err := parseContent(body)
//skip parse error
if err != nil {
log.Printf("parse email body error")
errorInfo := ErrorInfo{Code: 403, Name: ""}
resp := EmailJsonResponse{Success: false, Error: errorInfo}
w.WriteJson(&resp)
return
}
content.SenderAddr = senderAddr
content.SenderName = ""
content.Subject = subject
content.Content = body
resp := EmailJsonResponse{Success: true, Data: content}
w.WriteJson(&resp)
}
//防止与email包冲突
func (*Email) SendEmailContent(w rest.ResponseWriter, r *rest.Request) {
log.Printf("send email...")
addr := r.FormValue("smtpAddr")
port := r.FormValue("smtpPort")
user := r.FormValue("user")
pwd := r.FormValue("pwd")
address := addr + ":" + port
log.Printf("smtp address %s\n", address)
//从请求报文body中解析json串，获取发文地址及主题、正文、附件等
if r.Body == nil {
log.Printf("request body is null")
return
}
reqJson, err := ioutil.ReadAll(r.Body)
if err != nil {
log.Printf("when read request body error: %s", err)
return
}
defer r.Body.Close()
log.Printf("request body: %s", string(reqJson))
var emailReq EmailJsonRequest
err = json.Unmarshal(reqJson, &emailReq)
if err != nil {
log.Printf("unmarshal req json error, %s", err)
return
}
log.Printf("%v", emailReq)
log.Printf("from addrs: %s", user)
to := emailReq.Data.RecverAddrList
log.Printf("send to addrs: %v", to)
auth := smtp.PlainAuth("", user, pwd, addr)
str := strings.Replace("From: "+user+"~To: "+to[0]+"~Subject: "+"this is subject"+"~~", "~", "\r\n", -1) + "this is body msg"
//多个收件人时需要循环发送，一次构造一个收件人[]string
err = smtp.SendMail(address, auth, user, []string{to[0]}, []byte(str))
//处理附件，从emailReq.Data.Attachements中取出名称和内容
//使用net/smtp发送邮件
resp := EmailJsonResponse{}
if err == nil {
log.Printf("send mail ok\n")
resp.Success = true
} else {
log.Printf("send mail error: %s", err)
resp.Success = false
resp.Error = ErrorInfo{Code: 404, Name: "send mail error"}
}
w.WriteJson(&resp)
}
// POST /releases/update
func ReleaseUpdate(w rest.ResponseWriter, r *rest.Request) {
r.ParseForm()
// Parse form and append to struct
id, _ := strconv.ParseInt(r.FormValue("Id"), 10, 64)
fileId, _ := strconv.ParseInt(r.FormValue("FileId"), 10, 64)
release := database.FindRelease(id)
file := database.FindFile(fileId)
release.FileId = file.Id
release.FileName = file.Name
release.Channel = r.FormValue("Channel")
release.Changelog = r.FormValue("Changelog")
// Append to db
database.UpdateRelease(release)
// Redirect
w.WriteJson("")
}
// POST /releases/create
func ReleaseCreate(w rest.ResponseWriter, r *rest.Request) {
r.ParseForm()
fileId, _ := strconv.ParseInt(r.FormValue("FileId"), 10, 64)
file := database.FindFile(fileId)
// Generate release
release := database.Release{
Created: time.Now().UnixNano(),
Changelog: r.FormValue("Changelog"),
Channel: r.FormValue("Channel"),
FileId: file.Id,
FileName: file.Name,
}
database.CreateRelease(release)
database.PublishFile(file)
go database.RefreshBuilds()
w.WriteJson("")
}
func (r *restServerAPI) UpdateGroup(w grest.ResponseWriter, req *grest.Request) {
g, err := r.ds.GroupByEmail(req.PathParam("email"))
if err != nil {
grest.Error(w, err.Error(), http.StatusNotFound)
return
}
user := req.Env["REMOTE_USER_OBJECT"].(*datasource.User)
action := req.FormValue("action")
switch action {
case "join":
if g.IsMemeber(user.Email) {
grest.Error(w, "Already joined", http.StatusNotAcceptable)
return
}
g.Members = append(g.Members, user.Email)
case "leave":
if g.Manager == user.Email {
grest.Error(w, "You can't leave a group you which you manage", http.StatusNotAcceptable)
return
}
leaved := false
for i, m := range g.Members {
if m == user.Email {
leaved = true
n := len(g.Members)
g.Members[i] = g.Members[n-1]
g.Members = g.Members[:n-1]
break
}
}
if !leaved {
grest.Error(w, "Not joined anyway", http.StatusNotAcceptable)
return
}
case "update":
if !user.Admin && g.Manager != user.Email {
grest.Error(w, "You can't modify this group", http.StatusForbidden)
return
}
var gTemp datasource.Group
err := req.DecodeJsonPayload(&gTemp)
if err != nil {
grest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
g.Name = gTemp.Name
g.Description = gTemp.Description
g.Active = gTemp.Active
g.Public = gTemp.Public
g.Joinable = gTemp.Joinable
g.Manager = gTemp.Manager
g.CCs = gTemp.CCs
default:
grest.Error(w, fmt.Sprintf("Unknown action: %s", action), http.StatusNotAcceptable)
return
}
e := r.ds.StoreGroup(g)
if e != nil {
grest.Error(w, err.Error(), http.StatusInternalServerError)
return
} else {
w.WriteJson(g)
}
}
//use imap to delete a mail
func (email *Email) DeleteEmail(w rest.ResponseWriter, r *rest.Request) {
log.Printf("delete email...")
addr := r.FormValue("imapAddr")
//port := r.FormValue("smtpPort")
user := r.FormValue("user")
pwd := r.FormValue("pwd")
id := r.FormValue("id")
//check params, return error
//create imap client
var (
c *imap.Client
cmd *imap.Command
rsp *imap.Response
)
// Connect to the server
c, _ = imap.Dial(addr)
// Remember to log out and close the connection when finished
defer c.Logout(30 * time.Second)
// Print server greeting (first response in the unilateral server data queue)
log.Printf("Server says hello:%s", c.Data[0].Info)
c.Data = nil
// Enable encryption, if supported by the server
if c.Caps["STARTTLS"] {
c.StartTLS(nil)
}
// Authenticate
if c.State() == imap.Login {
c.Login(user, pwd)
}
// List all top-level mailboxes, wait for the command to finish
cmd, _ = imap.Wait(c.List("", "%"))
// Print mailbox information
log.Printf("\nTop-level mailboxes:")
for _, rsp = range cmd.Data {
log.Printf("|--%s", rsp.MailboxInfo())
}
// Check for new unilateral server data responses
for _, rsp = range c.Data {
log.Printf("Server data:%s", rsp)
}
c.Data = nil
// Open a mailbox (synchronous command - no need for imap.Wait)
c.Select("INBOX", true)
log.Printf("\nMailbox status:%s\n", c.Mailbox)
if c.Mailbox == nil {
resp := EmailJsonResponse{Success: true}
w.WriteJson(&resp)
return
}
//use Expunge to delete a mail
set, _ := imap.NewSeqSet("")
mid, _ := strconv.Atoi(id)
set.AddNum(uint32(mid))
//delete mail
cmd, err := c.Expunge(set)
if err != nil {
log.Printf("%v ", cmd)
} else {
log.Printf("delete mail ok")
}
}
func postRouterCommand(w rest.ResponseWriter, r *rest.Request) {
log.Debugf("Request from RemoterAddr: %s", r.RemoteAddr)
resp := CommandResponse{}
resp.Status = STATUS_OK
uid := r.FormValue("uid")
if uid == "" {
resp.Status = STATUS_INVALID_PARAM
resp.Error = "missing 'uid'"
w.WriteJson(resp)
return
}
rid := r.FormValue("rid")
if rid == "" {
resp.Status = STATUS_INVALID_PARAM
resp.Error = "missing 'rid'"
w.WriteJson(resp)
return
}
if !checkAuthzUid(uid, rid) {
log.Warnf("auth failed. uid: %s, rid: %s", uid, rid)
resp.Status = STATUS_OTHER_ERR
resp.Error = "authorization failed"
w.WriteJson(resp)
return
}
if r.Body == nil {
resp.Status = STATUS_INVALID_PARAM
resp.Error = "missing POST data"
w.WriteJson(resp)
return
}
body, err := ioutil.ReadAll(r.Body)
r.Body.Close()
if err != nil {
resp.Status = STATUS_INVALID_PARAM
resp.Error = "invalid POST body"
w.WriteJson(resp)
return
}
var cmd string
var serviceName string
if len(rid) == len("c80e774a1e78") {
// To old agent
serviceName = "gibbon_agent"
type CommandRequest struct {
//Uid string `json:"uid"`
Cmd string `json:"cmd"`
}
cmdRequest := CommandRequest{
//Uid: uid,
Cmd: string(body),
}
bCmd, _ := json.Marshal(cmdRequest)
cmd = string(bCmd)
} else {
// To new android service
serviceName = "com.letv.letvroutersettingservice"
type RouterCommand struct {
Forward string `json:"forward"`
}
var rc RouterCommand
if err := json.Unmarshal([]byte(body), &rc); err != nil {
resp.Status = -2000
resp.Error = "Request body is not JSON"
w.WriteJson(resp)
return
}
cmd = rc.Forward
if cmd == "" {
resp.Status = -2001
resp.Error = "'forward' is empty"
w.WriteJson(resp)
return
}
}
stats.Cmd(serviceName)
result, err := rpcClient.Control(rid, serviceName, cmd)
if err != nil {
if _, ok := err.(*mq.NoDeviceError); ok {
stats.CmdOffline(serviceName)
resp.Status = STATUS_ROUTER_OFFLINE
resp.Error = fmt.Sprintf("device (%s) offline", rid)
} else if _, ok := err.(*mq.TimeoutError); ok {
stats.CmdTimeout(serviceName)
resp.Status = STATUS_OTHER_ERR
resp.Error = fmt.Sprintf("recv response timeout [%s]", rid)
} else if _, ok := err.(*mq.InvalidServiceError); ok {
stats.CmdInvalidService(serviceName)
resp.Status = STATUS_OTHER_ERR
resp.Error = fmt.Sprintf("Device [%s] has no service [%s]", rid, serviceName)
} else {
stats.CmdOtherError(serviceName)
resp.Status = STATUS_OTHER_ERR
resp.Error = err.Error()
}
w.WriteJson(resp)
return
} else {
stats.CmdSuccess(serviceName)
if len(rid) == len("c80e774a1e78") {
// reply from gibbon agent
w.(http.ResponseWriter).Write([]byte(result))
} else {
// reply from android service
type RouterCommandReply struct {
Status int `json:"status"`
Descr string `json:"descr"`
Result string `json:"result"`
}
var reply RouterCommandReply
reply.Status = 0
reply.Descr = "OK"
reply.Result = result
w.WriteJson(reply)
}
}
}
func (emaill *Email) getEmailContentUseIMAP(w rest.ResponseWriter, r *rest.Request) {
addr := r.FormValue("imapAddr")
port := r.FormValue("imapPort")
user := r.FormValue("user")
pwd := r.FormValue("pwd")
id := r.FormValue("id")
address := addr + ":" + port
log.Printf("get email content use imap %s\n", address)
var (
c *imap.Client
cmd *imap.Command
rsp *imap.Response
)
// Connect to the server
c, err := imap.Dial(addr)
if err != nil {
log.Printf("dial %s error\n", address)
return
}
// Remember to log out and close the connection when finished
defer c.Logout(30 * time.Second)
// Print server greeting (first response in the unilateral server data queue)
log.Printf("Server says hello:%s", c.Data[0].Info)
c.Data = nil
// Enable encryption, if supported by the server
if c.Caps["STARTTLS"] {
c.StartTLS(nil)
}
// Authenticate
if c.State() == imap.Login {
c.Login(user, pwd)
}
// List all top-level mailboxes, wait for the command to finish
cmd, _ = imap.Wait(c.List("", "%"))
// Print mailbox information
log.Printf("\nTop-level mailboxes:")
for _, rsp = range cmd.Data {
log.Printf("|--%s", rsp.MailboxInfo())
}
// Check for new unilateral server data responses
for _, rsp = range c.Data {
log.Printf("Server data:%s", rsp)
}
c.Data = nil
// Open a mailbox (synchronous command - no need for imap.Wait)
c.Select("INBOX", true)
log.Printf("\nMailbox status:%s\n", c.Mailbox)
if c.Mailbox == nil {
resp := EmailJsonResponse{Success: true}
w.WriteJson(&resp)
return
}
// Fetch the headers of the 10 most recent messages
set, _ := imap.NewSeqSet("")
set.Add(id)
// if c.Mailbox.Messages >= 10 {
// set.AddRange(c.Mailbox.Messages-9, c.Mailbox.Messages) //测试只取最新一封邮件
// } else {
// set.Add("1:*")
// }
cmd, _ = c.Fetch(set, "RFC822.HEADER", "RFC822.TEXT") //指定要获取的内容
// Process responses while the command is running
log.Printf("\nget mail [%s] messages:", id)
for cmd.InProgress() {
// Wait for the next response (no timeout)
c.Recv(-1)
// Process command data
for _, rsp = range cmd.Data {
header := imap.AsBytes(rsp.MessageInfo().Attrs["RFC822.HEADER"])
if msg, _ := mail.ReadMessage(bytes.NewReader(header)); msg != nil {
subject := msg.Header.Get("Subject")
log.Printf("|--%s", subject)
realSubject := GetRealSubject(subject)
log.Printf("in rest_email.go: get real subject")
log.Printf(realSubject)
senderAddr := msg.Header.Get("From")
recverAddrList := msg.Header.Get("To")
realSenderAddr := GetRealSubject(senderAddr)
realRecverAddrList := GetRealSubject(recverAddrList)
body := imap.AsBytes(rsp.MessageInfo().Attrs["RFC822.TEXT"])
//log.Printf("email body: %s", body)
//realBody := GetRealBody(string(body))
headerAndBody := make([]byte, len(header)+len(body))
copy(headerAndBody, header)
copy(headerAndBody[len(header):], body)
msg, _ := mail.ReadMessage(bytes.NewReader(headerAndBody))
mime, _ := enmime.ParseMIMEBody(msg)
realBody := mime.Text //如果原始内容为html，会去掉html元素标签
log.Printf("real body: %s", realBody)
//获取MIMEPart所有节点内容
// log.Printf("root ======================")
// root := mime.Root
// if root != nil {
// log.Printf(string(root.Content()))
// log.Printf("child==========")
// if child := root.FirstChild(); child != nil {
// log.Printf(string(child.Content()))
// }
// }
attachments := mime.Attachments
log.Printf("attachments len=%d", len(attachments))
count := len(attachments)
var attachmentList []Attachment = nil
var data EmailContent
if count > 0 {
attachmentList = make([]Attachment, count)
for i := 0; i < len(attachments); i++ {
name := attachments[i].FileName()
content := attachments[i].Content() //todo encode by base64
log.Printf("name===%s", name)
attachmentList[i] = Attachment{Name: name, Body: string(content)}
}
}
data = EmailContent{Subject: realSubject, SenderAddr: realSenderAddr,
RecverAddrList: realRecverAddrList, Content: realBody,
Attachments: attachmentList}
resp := EmailJsonResponse{Success: true, Data: data}
w.WriteJson(resp)
}
}
cmd.Data = nil
// Process unilateral server data
for _, rsp = range c.Data {
log.Printf("Server data:%s", rsp)
}
c.Data = nil
}
// Check command completion status
if rsp, err := cmd.Result(imap.OK); err != nil {
if err == imap.ErrAborted {
log.Printf("Fetch command aborted\n")
} else {
log.Printf("Fetch error:%s\n", rsp.Info)
}
}
}
func (r *restServerAPI) UpdateUser(w grest.ResponseWriter, req *grest.Request) {
currentUser := req.Env["REMOTE_USER_OBJECT"].(*datasource.User)
email := req.PathParam("email")
var user *datasource.User
var err error
if email == currentUser.Email {
user = currentUser
} else {
if !currentUser.Admin {
grest.Error(w, "Access denied", http.StatusForbidden)
return
}
user, err = r.ds.UserByEmail(email)
if err != nil {
grest.Error(w, err.Error(), http.StatusNotFound)
return
}
}
action := req.FormValue("action")
switch action {
case "changePassword":
salt := r.ds.ConfigByteArray("PASSWORD_SALT")
var cp ChangePassword
err = req.DecodeJsonPayload(&cp)
if err != nil {
grest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
if user.HasPassword() && !user.AcceptsPassword(cp.OldPassword, salt) {
grest.Error(w, "Old password is incorrect", http.StatusForbidden)
return
}
user.SetPassword(cp.NewPassword, salt)
// TODO notify
case "update":
var uTemp datasource.User
err = req.DecodeJsonPayload(&uTemp)
if err != nil {
grest.Error(w, err.Error(), http.StatusInternalServerError)
return
}
user.UIDStr = uTemp.UIDStr
user.InboxAddr = uTemp.InboxAddr // TODO notify the previous InboxAddr
user.Active = uTemp.Active
user.Admin = uTemp.Admin
user.EnFirstName = uTemp.EnFirstName
user.EnLastName = uTemp.EnLastName
user.FaFirstName = uTemp.FaFirstName
user.FaLastName = uTemp.FaLastName
user.MobileNum = uTemp.MobileNum
user.EmergencyNum = uTemp.EmergencyNum
user.BirthDate = uTemp.BirthDate
user.EnrolmentDate = uTemp.EnrolmentDate
user.LeavingDate = uTemp.LeavingDate
default:
grest.Error(w, fmt.Sprintf("Unknown action: %s", action), http.StatusNotAcceptable)
return
}
e := r.ds.StoreUser(user)
if e != nil {
grest.Error(w, err.Error(), http.StatusInternalServerError)
return
} else {
w.WriteJson(user)
}
}