func (con UserSettings) Handler(c context.Context) http.Handler { cfg := readeef.GetConfig(c) return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { user := readeef.GetUser(c, r) params := webfw.GetParams(c, r) attr := params["attribute"] var resp responseError if r.Method == "GET" { resp = getUserAttribute(user, attr) } else if r.Method == "POST" { buf := util.BufferPool.GetBuffer() defer util.BufferPool.Put(buf) buf.ReadFrom(r.Body) resp = setUserAttribute(user, []byte(cfg.Auth.Secret), attr, buf.Bytes()) } var b []byte if resp.err == nil { b, resp.err = json.Marshal(resp.val) } if resp.err != nil { webfw.GetLogger(c).Print(resp.err) w.WriteHeader(http.StatusInternalServerError) return } w.Write(b) }) }
func (con Auth) Handler(c context.Context) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { action := webfw.GetMultiPatternIdentifier(c, r) sess := webfw.GetSession(c, r) var resp responseError switch action { case "auth-data": user := readeef.GetUser(c, r) resp = getAuthData(user, sess, con.capabilities) case "logout": resp = logout(sess) } var b []byte if resp.err == nil { b, resp.err = json.Marshal(resp.val) } if resp.err == nil { w.Write(b) } else { webfw.GetLogger(c).Print(resp.err) w.WriteHeader(http.StatusInternalServerError) return } }) }
func (con User) Handler(c context.Context) http.Handler { cfg := readeef.GetConfig(c) return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { user := readeef.GetUser(c, r) action := webfw.GetMultiPatternIdentifier(c, r) params := webfw.GetParams(c, r) var resp responseError switch action { case "list": resp = listUsers(user) case "add": buf := util.BufferPool.GetBuffer() defer util.BufferPool.Put(buf) buf.ReadFrom(r.Body) resp = addUser(user, data.Login(params["login"]), buf.String(), []byte(cfg.Auth.Secret)) case "remove": resp = removeUser(user, data.Login(params["login"])) case "setAttr": resp = setAttributeForUser(user, []byte(cfg.Auth.Secret), data.Login(params["login"]), params["attr"], []byte(params["value"])) } switch resp.err { case errForbidden: w.WriteHeader(http.StatusForbidden) return case errUserExists: resp.val["Error"] = true resp.val["ErrorType"] = resp.errType resp.err = nil case errCurrentUser: resp.val["Error"] = true resp.val["ErrorType"] = resp.errType resp.err = nil } var b []byte if resp.err == nil { b, resp.err = json.Marshal(resp.val) } if resp.err != nil { webfw.GetLogger(c).Print(resp.err) w.WriteHeader(http.StatusInternalServerError) return } w.Write(b) }) }
func (con Auth) Handler(c context.Context) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { user := readeef.GetUser(c, r) resp := getAuthData(user) b, err := json.Marshal(resp.val) if err != nil { webfw.GetLogger(c).Print(err) w.WriteHeader(http.StatusInternalServerError) return } w.Write(b) }) }
func (con Article) Handler(c context.Context) http.Handler { logger := webfw.GetLogger(c) return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { user := readeef.GetUser(c, r) params := webfw.GetParams(c, r) action := webfw.GetMultiPatternIdentifier(c, r) logger.Infof("Invoking Article controller with action '%s', article id '%s'\n", action, params["article-id"]) var articleId int64 var resp responseError articleId, resp.err = strconv.ParseInt(params["article-id"], 10, 64) if resp.err == nil { id := data.ArticleId(articleId) switch action { case "fetch": resp = fetchArticle(user, id) case "read": resp = articleReadState(user, id, params["value"] == "true") case "favorite": resp = articleFavoriteState(user, id, params["value"] == "true") case "format": resp = formatArticle(user, id, con.extractor, webfw.GetConfig(c), con.config) } } var b []byte if resp.err == nil { b, resp.err = json.Marshal(resp.val) } if resp.err == nil { w.Write(b) } else { webfw.GetLogger(c).Print(resp.err) w.WriteHeader(http.StatusInternalServerError) } }) }
func (con Auth) Handler(c context.Context) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { user := readeef.GetUser(c, r) type User struct { Login string FirstName string LastName string Email string Admin bool } type response struct { Auth bool User User ProfileData map[string]interface{} } resp := response{ Auth: true, User: User{ Login: user.Login, FirstName: user.FirstName, LastName: user.LastName, Email: user.Email, Admin: user.Admin, }, ProfileData: user.ProfileData, } b, err := json.Marshal(resp) if err != nil { webfw.GetLogger(c).Print(err) w.WriteHeader(http.StatusInternalServerError) return } w.Write(b) } }
func (con Search) Handler(c context.Context) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { user := readeef.GetUser(c, r) params := webfw.GetParams(c, r) query := params["query"] var resp responseError if resp.err = r.ParseForm(); resp.err == nil { highlight := "" feedId := "" if vs := r.Form["highlight"]; len(vs) > 0 { highlight = vs[0] } if vs := r.Form["id"]; len(vs) > 0 { if vs[0] != "all" && vs[0] != "favorite" { feedId = vs[0] } } resp = search(user, con.searchIndex, query, highlight, feedId) } var b []byte if resp.err == nil { b, resp.err = json.Marshal(resp.val) } if resp.err != nil { webfw.GetLogger(c).Print(resp.err) w.WriteHeader(http.StatusInternalServerError) return } w.Write(b) }) }
func (con Feed) Handler(c context.Context) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var err error db := readeef.GetDB(c) user := readeef.GetUser(c, r) action := webfw.GetMultiPatternIdentifier(c, r) params := webfw.GetParams(c, r) resp := make(map[string]interface{}) SWITCH: switch action { case "list": var feeds []readeef.Feed feeds, err = db.GetUserTagsFeeds(user) if err != nil { break } respFeeds := []feed{} for _, f := range feeds { respFeeds = append(respFeeds, feed{ Id: f.Id, Title: f.Title, Description: f.Description, Link: f.Link, Image: f.Image, Tags: f.Tags, UpdateError: f.UpdateError, SubscribeError: f.SubscribeError, }) } resp["Feeds"] = respFeeds case "discover": r.ParseForm() link := r.FormValue("url") var u *url.URL /* TODO: non-fatal error */ if u, err = url.Parse(link); err != nil { break /* TODO: non-fatal error */ } else if !u.IsAbs() { u.Scheme = "http" if u.Host == "" { parts := strings.SplitN(u.Path, "/", 2) u.Host = parts[0] if len(parts) > 1 { u.Path = "/" + parts[1] } else { u.Path = "" } } link = u.String() } var feeds []readeef.Feed feeds, err = con.fm.DiscoverFeeds(link) if err != nil { break } var userFeeds []readeef.Feed userFeeds, err = db.GetUserFeeds(user) if err != nil { break } userFeedIdMap := make(map[int64]bool) userFeedLinkMap := make(map[string]bool) for _, f := range userFeeds { userFeedIdMap[f.Id] = true userFeedLinkMap[f.Link] = true u, err := url.Parse(f.Link) if err == nil && strings.HasPrefix(u.Host, "www.") { u.Host = u.Host[4:] userFeedLinkMap[u.String()] = true } } respFeeds := []feed{} for _, f := range feeds { if !userFeedIdMap[f.Id] && !userFeedLinkMap[f.Link] { respFeeds = append(respFeeds, feed{ Id: f.Id, Title: f.Title, Description: f.Description, Link: f.Link, Image: f.Image, }) } } resp["Feeds"] = respFeeds case "opml": buf := util.BufferPool.GetBuffer() defer util.BufferPool.Put(buf) buf.ReadFrom(r.Body) var opml parser.Opml opml, err = parser.ParseOpml(buf.Bytes()) if err != nil { break } var userFeeds []readeef.Feed userFeeds, err = db.GetUserFeeds(user) if err != nil { break } userFeedMap := make(map[int64]bool) for _, f := range userFeeds { userFeedMap[f.Id] = true } var feeds []readeef.Feed for _, opmlFeed := range opml.Feeds { var discovered []readeef.Feed discovered, err = con.fm.DiscoverFeeds(opmlFeed.Url) if err != nil { continue } for _, f := range discovered { if !userFeedMap[f.Id] { if len(opmlFeed.Tags) > 0 { f.Link += "#" + strings.Join(opmlFeed.Tags, ",") } feeds = append(feeds, f) } } } respFeeds := []feed{} for _, f := range feeds { respFeeds = append(respFeeds, feed{ Id: f.Id, Title: f.Title, Description: f.Description, Link: f.Link, Image: f.Image, }) } resp["Feeds"] = respFeeds case "add": r.ParseForm() links := r.Form["url"] success := false for _, link := range links { /* TODO: non-fatal error */ var u *url.URL if u, err = url.Parse(link); err != nil { break SWITCH /* TODO: non-fatal error */ } else if !u.IsAbs() { err = errors.New("Feed has no link") break SWITCH } var f readeef.Feed f, err = con.fm.AddFeedByLink(link) if err != nil { break SWITCH } f, err = db.CreateUserFeed(readeef.GetUser(c, r), f) if err != nil { break SWITCH } tags := strings.SplitN(u.Fragment, ",", -1) if u.Fragment != "" && len(tags) > 0 { err = db.CreateUserFeedTag(f, tags...) } success = true } resp["Success"] = success case "remove": var id int64 id, err = strconv.ParseInt(params["feed-id"], 10, 64) /* TODO: non-fatal error */ if err != nil { break } var feed readeef.Feed feed, err = db.GetUserFeed(id, user) /* TODO: non-fatal error */ if err != nil { break } err = db.DeleteUserFeed(feed) /* TODO: non-fatal error */ if err != nil { break } con.fm.RemoveFeed(feed) resp["Success"] = true case "tags": var id int64 id, err = strconv.ParseInt(params["feed-id"], 10, 64) /* TODO: non-fatal error */ if err != nil { break } var feed readeef.Feed feed, err = db.GetUserFeed(id, user) /* TODO: non-fatal error */ if err != nil { break } if r.Method == "GET" { resp["Tags"] = feed.Tags } else if r.Method == "POST" { var tags []string tags, err = db.GetUserFeedTags(user, feed) if err != nil { break } err = db.DeleteUserFeedTag(feed, tags...) if err != nil { break } decoder := json.NewDecoder(r.Body) tags = []string{} err = decoder.Decode(&tags) if err != nil { break } err = db.CreateUserFeedTag(feed, tags...) if err != nil { break } resp["Success"] = true resp["Id"] = feed.Id } case "read": feedId := params["feed-id"] timestamp := params["timestamp"] var seconds int64 seconds, err = strconv.ParseInt(timestamp, 10, 64) /* TODO: non-fatal error */ if err != nil { break } t := time.Unix(seconds/1000, 0) switch { case feedId == "tag:__all__": err = db.MarkUserArticlesByDateAsRead(user, t, true) case feedId == "__favorite__": // Favorites are assumbed to have been read already case strings.HasPrefix(feedId, "tag:"): tag := feedId[4:] err = db.MarkUserTagArticlesByDateAsRead(user, tag, t, true) default: var id int64 id, err = strconv.ParseInt(feedId, 10, 64) /* TODO: non-fatal error */ if err != nil { break SWITCH } var feed readeef.Feed feed, err = db.GetUserFeed(id, user) /* TODO: non-fatal error */ if err != nil { break SWITCH } err = db.MarkFeedArticlesByDateAsRead(feed, t, true) } if err == nil { resp["Success"] = true } case "articles": var articles []readeef.Article var limit, offset int feedId := params["feed-id"] limit, err = strconv.Atoi(params["limit"]) /* TODO: non-fatal error */ if err != nil { break } offset, err = strconv.Atoi(params["offset"]) /* TODO: non-fatal error */ if err != nil { break } newerFirst := params["newer-first"] == "true" unreadOnly := params["unread-only"] == "true" if limit > 50 { limit = 50 } if feedId == "__favorite__" { if newerFirst { articles, err = db.GetUserFavoriteArticlesDesc(user, limit, offset) } else { articles, err = db.GetUserFavoriteArticles(user, limit, offset) } if err != nil { break } } else if feedId == "tag:__all__" { if newerFirst { if unreadOnly { articles, err = db.GetUnreadUserArticlesDesc(user, limit, offset) } else { articles, err = db.GetUserArticlesDesc(user, limit, offset) } } else { if unreadOnly { articles, err = db.GetUnreadUserArticles(user, limit, offset) } else { articles, err = db.GetUserArticles(user, limit, offset) } } if err != nil { break } } else if strings.HasPrefix(feedId, "tag:") { tag := feedId[4:] if newerFirst { if unreadOnly { articles, err = db.GetUnreadUserTagArticlesDesc(user, tag, limit, offset) } else { articles, err = db.GetUserTagArticlesDesc(user, tag, limit, offset) } } else { if unreadOnly { articles, err = db.GetUnreadUserTagArticles(user, tag, limit, offset) } else { articles, err = db.GetUserTagArticles(user, tag, limit, offset) } } if err != nil { break } } else { var f readeef.Feed var id int64 id, err = strconv.ParseInt(feedId, 10, 64) if err != nil { err = errors.New("Unknown feed id " + feedId) break } f, err = db.GetFeed(id) /* TODO: non-fatal error */ if err != nil { break } f.User = user if newerFirst { if unreadOnly { f, err = db.GetUnreadFeedArticlesDesc(f, limit, offset) } else { f, err = db.GetFeedArticlesDesc(f, limit, offset) } } else { if unreadOnly { f, err = db.GetUnreadFeedArticles(f, limit, offset) } else { f, err = db.GetFeedArticles(f, limit, offset) } } if err != nil { break } articles = f.Articles } resp["Articles"] = articles } var b []byte if err == nil { b, err = json.Marshal(resp) } if err == nil { w.Write(b) } else { webfw.GetLogger(c).Print(err) w.WriteHeader(http.StatusInternalServerError) } } }
func (con Article) Handler(c context.Context) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var err error db := readeef.GetDB(c) user := readeef.GetUser(c, r) params := webfw.GetParams(c, r) action := params["action"] readeef.Debug.Printf("Invoking Article controller with action '%s', feed id '%s' and article id '%s'\n", action, params["feed-id"], params["article-id"]) var feedId int64 feedId, err = strconv.ParseInt(params["feed-id"], 10, 64) var article readeef.Article if err == nil { article, err = db.GetFeedArticle(feedId, params["article-id"], user) } if err == nil { switch action { case "read": read := params["value"] == "true" previouslyRead := article.Read if previouslyRead != read { err = db.MarkUserArticlesAsRead(user, []readeef.Article{article}, read) if err != nil { break } } type response struct { Success bool Read bool } resp := response{Success: previouslyRead != read, Read: read} var b []byte b, err = json.Marshal(resp) if err != nil { break } w.Write(b) case "favorite": favorite := params["value"] == "true" previouslyFavorite := article.Favorite if previouslyFavorite != favorite { err = db.MarkUserArticlesAsFavorite(user, []readeef.Article{article}, favorite) if err != nil { break } } type response struct { Success bool Favorite bool } resp := response{Success: previouslyFavorite != favorite, Favorite: favorite} var b []byte b, err = json.Marshal(resp) if err != nil { break } w.Write(b) } } if err != nil { webfw.GetLogger(c).Print(err) w.WriteHeader(http.StatusInternalServerError) } } }
func (con WebSocket) Handler(c context.Context) http.Handler { var mutex sync.RWMutex receivers := make(map[chan content.Feed]bool) logger := webfw.GetLogger(c) go func() { for { select { case feed := <-con.updateFeed: logger.Infoln("New articles notification for " + feed.String()) mutex.RLock() for receiver, _ := range receivers { receiver <- feed } mutex.RUnlock() } } }() cfg := readeef.GetConfig(c) return websocket.Handler(func(ws *websocket.Conn) { user := readeef.GetUser(c, ws.Request()) sess := webfw.GetSession(c, ws.Request()) msg := make(chan apiRequest) resp := make(chan apiResponse) receiver := make(chan content.Feed) mutex.Lock() receivers[receiver] = true mutex.Unlock() defer func() { mutex.Lock() close(receiver) delete(receivers, receiver) mutex.Unlock() }() go func() { for { var r responseError select { case data := <-msg: var err error var processor Processor if processor, err = data.processor(c, sess, user, con.fm, con.sp, con.extractor, con.capabilities, []byte(cfg.Auth.Secret)); err == nil { if len(data.Arguments) > 0 { err = json.Unmarshal([]byte(data.Arguments), processor) } if err == nil { r = processor.Process() } } if err != nil { r.err = err switch err.(type) { case *json.UnmarshalTypeError: r.errType = errTypeInvalidArgValue default: if err == errInvalidMethodValue { r.errType = errTypeInvalidMethodValue } else if err == content.ErrNoContent { r.err = errResourceNotFound r.errType = errTypeResourceNotFound } } } go func() { var err string if r.err != nil { err = r.err.Error() } resp <- apiResponse{ Success: r.err == nil, Error: err, ErrorType: r.errType, Method: data.Method, Tag: data.Tag, Arguments: r.val, } }() case f := <-receiver: if f == nil || user == nil { // Socket was closed return } logger.Infoln("Received notification for feed update of " + f.String()) r := newResponse() uf := user.FeedById(f.Data().Id) if !uf.HasErr() { r.val["Feed"] = uf go func() { var err string if r.err != nil { err = r.err.Error() } resp <- apiResponse{ Success: r.err == nil, Error: err, ErrorType: r.errType, Method: "feed-update-notifier", Tag: "", Arguments: r.val, } }() } case r := <-resp: websocket.JSON.Send(ws, r) } } }() for { var data apiRequest if err := websocket.JSON.Receive(ws, &data); err != nil { if err == io.EOF { // Websocket was closed break } else { websocket.JSON.Send(ws, apiResponse{ Success: false, ErrorType: errTypeMessageParse, Error: err.Error(), Method: data.Method, }) } } if forbidden(c, ws.Request()) { websocket.JSON.Send(ws, apiResponse{ Success: false, ErrorType: errTypeUnauthorized, Error: errUnauthorized.Error(), Method: data.Method, }) break } msg <- data } logger.Infoln("Closing web socket") }) }
func (con Feed) Handler(c context.Context) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { action := webfw.GetMultiPatternIdentifier(c, r) user := readeef.GetUser(c, r) r.ParseForm() var resp responseError var feedId int64 params := webfw.GetParams(c, r) switch action { case "list": resp = listFeeds(user) case "discover": link := r.FormValue("url") resp = discoverFeeds(user, con.fm, link) case "opml-export": resp = exportOpml(user) case "opml": buf := util.BufferPool.GetBuffer() defer util.BufferPool.Put(buf) buf.ReadFrom(r.Body) resp = parseOpml(user, con.fm, buf.Bytes()) case "add": links := r.Form["url"] resp = addFeeds(user, con.fm, links) case "remove": if feedId, resp.err = strconv.ParseInt(params["feed-id"], 10, 64); resp.err == nil { resp = removeFeed(user, con.fm, data.FeedId(feedId)) } case "tags": if feedId, resp.err = strconv.ParseInt(params["feed-id"], 10, 64); resp.err == nil { if r.Method == "GET" { resp = getFeedTags(user, data.FeedId(feedId)) } else if r.Method == "POST" { if b, err := ioutil.ReadAll(r.Body); err == nil { tags := []data.TagValue{} if err = json.Unmarshal(b, &tags); err != nil { resp.err = fmt.Errorf("Error decoding request body: %s", err) break } resp = setFeedTags(user, data.FeedId(feedId), tags) } else { resp.err = fmt.Errorf("Error reading request body: %s", err) break } } } case "read": var timestamp, beforeId int64 if bid, ok := params["before-id"]; ok { beforeId, resp.err = strconv.ParseInt(bid, 10, 64) } else { timestamp, resp.err = strconv.ParseInt(params["timestamp"], 10, 64) } if resp.err == nil { resp = readState(user, params["feed-id"], data.ArticleId(beforeId), timestamp) } case "articles": var limit, offset int if limit, resp.err = strconv.Atoi(params["limit"]); resp.err == nil { if offset, resp.err = strconv.Atoi(params["offset"]); resp.err == nil { minId, _ := strconv.ParseInt(params["min-id"], 10, 64) maxId, _ := strconv.ParseInt(params["max-id"], 10, 64) resp = getFeedArticles(user, con.sp, params["feed-id"], data.ArticleId(minId), data.ArticleId(maxId), limit, offset, params["older-first"] == "true", params["unread-only"] == "true") } } } switch resp.err { case readeef.ErrNoAbsolute: resp.val["Error"] = true resp.val["ErrorType"] = errTypeNoAbsolute resp.err = nil case readeef.ErrNoFeed: resp.val["Error"] = true resp.val["ErrorType"] = errTypeNoFeed resp.err = nil } var b []byte if resp.err == nil { b, resp.err = json.Marshal(resp.val) } if resp.err == nil { w.Write(b) } else { webfw.GetLogger(c).Print(resp.err) w.WriteHeader(http.StatusInternalServerError) } }) }
func (con UserSettings) Handler(c context.Context) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var err error db := readeef.GetDB(c) user := readeef.GetUser(c, r) params := webfw.GetParams(c, r) attr := params["attribute"] resp := map[string]interface{}{"Login": user.Login} if r.Method == "GET" { switch attr { case "FirstName": resp[attr] = user.FirstName case "LastName": resp[attr] = user.LastName case "Email": resp[attr] = user.Email case "ProfileData": resp[attr] = user.ProfileData default: err = errors.New("Error getting user attribute: unknown attribute " + attr) } } else if r.Method == "POST" { buf := util.BufferPool.GetBuffer() defer util.BufferPool.Put(buf) buf.ReadFrom(r.Body) switch attr { case "FirstName": user.FirstName = buf.String() case "LastName": user.LastName = buf.String() case "Email": user.Email = buf.String() case "ProfileData": err = json.Unmarshal(buf.Bytes(), &user.ProfileData) case "password": data := struct { Current string New string }{} err = json.Unmarshal(buf.Bytes(), &data) if err == nil { /* TODO: non-fatal error */ if user.Authenticate(data.Current) { err = user.SetPassword(data.New) } else { err = errors.New("Error change user password: current password is invalid") } } default: err = errors.New("Error getting user attribute: unknown attribute " + attr) } if err == nil { err = db.UpdateUser(user) } if err == nil { resp["Success"] = true resp["Attribute"] = attr } } var b []byte if err == nil { b, err = json.Marshal(resp) } if err != nil { webfw.GetLogger(c).Print(err) w.WriteHeader(http.StatusInternalServerError) return } w.Write(b) } }
func (con User) Handler(c context.Context) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { var err error db := readeef.GetDB(c) user := readeef.GetUser(c, r) if !user.Admin { readeef.Debug.Println("User " + user.Login + " is not an admin") w.WriteHeader(http.StatusForbidden) return } action := webfw.GetMultiPatternIdentifier(c, r) params := webfw.GetParams(c, r) resp := make(map[string]interface{}) switch action { case "list": users, err := db.GetUsers() if err != nil { break } type user struct { Login string FirstName string LastName string Email string Active bool Admin bool } userList := []user{} for _, u := range users { userList = append(userList, user{ Login: u.Login, FirstName: u.FirstName, LastName: u.LastName, Email: u.Email, Active: u.Active, Admin: u.Admin, }) } resp["Users"] = userList case "add": login := params["login"] _, err = db.GetUser(login) /* TODO: non-fatal error */ if err == nil { err = errors.New("User with login " + login + " already exists") break } else if err != sql.ErrNoRows { break } buf := util.BufferPool.GetBuffer() defer util.BufferPool.Put(buf) buf.ReadFrom(r.Body) u := readeef.User{Login: login} err = u.SetPassword(buf.String()) if err != nil { break } err = db.UpdateUser(u) if err != nil { break } resp["Success"] = true resp["Login"] = login case "remove": login := params["login"] if user.Login == login { err = errors.New("The current user cannot be removed") break } var u readeef.User u, err = db.GetUser(login) if err != nil { break } err = db.DeleteUser(u) if err != nil { break } resp["Success"] = true resp["Login"] = login case "active": login := params["login"] if user.Login == login { err = errors.New("The current user cannot be removed") break } active := params["state"] == "true" var u readeef.User u, err = db.GetUser(login) if err != nil { break } u.Active = active err = db.UpdateUser(u) if err != nil { break } resp["Success"] = true resp["Login"] = login } var b []byte if err == nil { b, err = json.Marshal(resp) } if err != nil { webfw.GetLogger(c).Print(err) w.WriteHeader(http.StatusInternalServerError) return } w.Write(b) } }
func (con Feed) Handler(c context.Context) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { action := webfw.GetMultiPatternIdentifier(c, r) user := readeef.GetUser(c, r) r.ParseForm() var resp responseError var feedId int64 params := webfw.GetParams(c, r) if resp.err == nil { switch action { case "list": resp = listFeeds(user) case "discover": link := r.FormValue("url") resp = discoverFeeds(user, con.fm, link) case "opml": buf := util.BufferPool.GetBuffer() defer util.BufferPool.Put(buf) buf.ReadFrom(r.Body) resp = parseOpml(user, con.fm, buf.Bytes()) case "add": links := r.Form["url"] resp = addFeed(user, con.fm, links) case "remove": if feedId, resp.err = strconv.ParseInt(params["feed-id"], 10, 64); resp.err == nil { resp = removeFeed(user, con.fm, data.FeedId(feedId)) } case "tags": if feedId, resp.err = strconv.ParseInt(params["feed-id"], 10, 64); resp.err == nil { if r.Method == "GET" { resp = getFeedTags(user, data.FeedId(feedId)) } else if r.Method == "POST" { decoder := json.NewDecoder(r.Body) tags := []data.TagValue{} if resp.err = decoder.Decode(&tags); resp.err != nil && resp.err != io.EOF { break } resp.err = nil resp = setFeedTags(user, data.FeedId(feedId), tags) } } case "read": var timestamp int64 if timestamp, resp.err = strconv.ParseInt(params["timestamp"], 10, 64); resp.err == nil { resp = markFeedAsRead(user, params["feed-id"], timestamp) } case "articles": var limit, offset int if limit, resp.err = strconv.Atoi(params["limit"]); resp.err == nil { if offset, resp.err = strconv.Atoi(params["offset"]); resp.err == nil { resp = getFeedArticles(user, params["feed-id"], limit, offset, params["newer-first"] == "true", params["unread-only"] == "true") } } } } switch resp.err { case readeef.ErrNoAbsolute: resp.val["Error"] = true resp.val["ErrorType"] = errTypeNoAbsolute resp.err = nil case readeef.ErrNoFeed: resp.val["Error"] = true resp.val["ErrorType"] = errTypeNoFeed resp.err = nil } var b []byte if resp.err == nil { b, resp.err = json.Marshal(resp.val) } if resp.err == nil { w.Write(b) } else { webfw.GetLogger(c).Print(resp.err) w.WriteHeader(http.StatusInternalServerError) } }) }