func (s *WalkthroughService) walkthroughPutHandler() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := hitch.Params(r).ByName("id")
entity := &Walkthrough{}
ab.MustDecode(r, entity)
if err := entity.Validate(); entity.UUID != id || err != nil {
ab.Fail(r, http.StatusBadRequest, err)
}
db := ab.GetDB(r)
abort := false
beforeWalkthroughPutUpdateHandler(r, entity, db)
if abort {
return
}
err := entity.Update(db)
ab.MaybeFail(r, http.StatusInternalServerError, ab.ConvertDBError(err, walkthroughDBErrorConverter))
afterWalkthroughPutUpdateHandler(s, entity)
if abort {
return
}
ab.Render(r).JSON(entity)
})
}
func (s *WalkthroughService) walkthroughPostHandler() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
entity := &Walkthrough{}
ab.MustDecode(r, entity)
abort := false
walkthroughPostValidation(entity, r)
if abort {
return
}
if err := entity.Validate(); err != nil {
ab.Fail(r, http.StatusBadRequest, err)
}
db := ab.GetDB(r)
err := entity.Insert(db)
ab.MaybeFail(r, http.StatusInternalServerError, ab.ConvertDBError(err, walkthroughDBErrorConverter))
afterWalkthroughPostInsertHandler(db, s, entity)
if abort {
return
}
ab.Render(r).SetCode(http.StatusCreated).JSON(entity)
})
}
func (s *WalkthroughService) walkthroughGetHandler() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := hitch.Params(r).ByName("id")
db := ab.GetDB(r)
abort := false
loadFunc := LoadWalkthrough
loadFunc = beforeWalkthroughGetHandler()
if abort {
return
}
entity, err := loadFunc(db, id)
ab.MaybeFail(r, http.StatusInternalServerError, ab.ConvertDBError(err, walkthroughDBErrorConverter))
if entity == nil {
ab.Fail(r, http.StatusNotFound, nil)
}
// HOOK: afterWalkthroughGetHandler()
if abort {
return
}
ab.Render(r).JSON(entity)
})
}
func (s *WalkthroughService) walkthroughListHandler() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
db := ab.GetDB(r)
loadFunc := LoadAllWalkthrough
abort := false
start := 0
limit := 25
if page := r.URL.Query().Get("page"); page != "" {
pagenum, err := strconv.Atoi(page)
ab.MaybeFail(r, http.StatusBadRequest, err)
start = (pagenum - 1) * limit
}
loadFunc = beforeWalkthroughListHandler()
if abort {
return
}
entities, err := loadFunc(db, start, limit)
ab.MaybeFail(r, http.StatusInternalServerError, ab.ConvertDBError(err, walkthroughDBErrorConverter))
// HOOK: afterWalkthroughListHandler()
if abort {
return
}
ab.Render(r).JSON(entities)
})
}
func (s *UserService) userPutHandler() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
id := hitch.Params(r).ByName("id")
entity := &User{}
ab.MustDecode(r, entity)
if err := entity.Validate(); entity.UUID != id || err != nil {
ab.Fail(r, http.StatusBadRequest, err)
}
db := ab.GetDB(r)
abort := false
// HOOK: beforeUserPutUpdateHandler()
if abort {
return
}
err := entity.Update(db)
ab.MaybeFail(r, http.StatusInternalServerError, ab.ConvertDBError(err, userDBErrorConverter))
// HOOK: afterUserPutUpdateHandler()
if abort {
return
}
ab.Render(r).JSON(entity)
})
}
func (s *UserService) userPostHandler() http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
entity := &User{}
ab.MustDecode(r, entity)
abort := false
// HOOK: userPostValidation()
if abort {
return
}
if err := entity.Validate(); err != nil {
ab.Fail(r, http.StatusBadRequest, err)
}
db := ab.GetDB(r)
err := entity.Insert(db)
ab.MaybeFail(r, http.StatusInternalServerError, ab.ConvertDBError(err, userDBErrorConverter))
// HOOK: afterUserPostInsertHandler()
if abort {
return
}
ab.Render(r).SetCode(http.StatusCreated).JSON(entity)
})
}
func afterUserServiceRegister(h *hitch.Hitch) {
h.Get("/api/user", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
sess := ab.GetSession(r)
if sess["uid"] != "" {
db := ab.GetDB(r)
user, err := LoadUser(db, sess["uid"])
ab.MaybeFail(r, http.StatusInternalServerError, err)
ab.Render(r).
JSON(user)
}
}))
}
func afterWalkthroughServiceRegister(s *WalkthroughService, h *hitch.Hitch) {
reindexing := false
var reindexingMutex sync.RWMutex
h.Post("/api/reindexwalkthroughs", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
reindexingMutex.RLock()
idxing := reindexing
reindexingMutex.RUnlock()
if idxing {
ab.Fail(r, http.StatusServiceUnavailable, errors.New("reindexing is in progress"))
}
reindexingMutex.Lock()
reindexing = true
reindexingMutex.Unlock()
db := ab.GetDB(r)
go func() {
defer func() {
reindexingMutex.Lock()
reindexing = false
reindexingMutex.Unlock()
}()
err := s.SearchService.PurgeIndex()
if err != nil {
log.Println(err)
return
}
wts, err := LoadAllActualWalkthroughs(db, 0, 0)
if err != nil {
log.Println(err)
return
}
for _, wt := range wts {
err = s.SearchService.IndexEntity("walkthrough", wt)
if err != nil {
log.Println(err)
return
}
}
}()
ab.Render(r).SetCode(http.StatusAccepted)
}), ab.RestrictPrivateAddressMiddleware())
}
func corsPreflightHandler(baseURL, httpOrigin string) http.Handler {
baseurl, err := url.Parse(baseURL)
if err != nil {
panic(err)
}
httporigin, err := url.Parse(httpOrigin)
if err != nil {
panic(err)
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
origin := r.Header.Get("Origin")
method := r.Header.Get("Access-Control-Request-Method")
headers := r.Header.Get("Access-Control-Request-Headers")
w.Header().Add("Vary", "Origin")
w.Header().Add("Vary", "Access-Control-Request-Method")
w.Header().Add("Vary", "Access-Control-Request-Headers")
if origin == "" || method == "" {
ab.Fail(r, http.StatusBadRequest, nil)
}
originurl, err := url.Parse(origin)
ab.MaybeFail(r, http.StatusBadRequest, err)
if originurl.Host != baseurl.Host && originurl.Host != httporigin.Host {
ab.Fail(r, http.StatusForbidden, nil)
}
w.Header().Set("Access-Control-Allow-Origin", origin)
w.Header().Set("Access-Control-Allow-Methods", method)
w.Header().Set("Access-Control-Allow-Headers", headers)
w.Header().Set("Access-Control-Allow-Credentials", "true")
w.Header().Set("Access-Control-Max-Age", "0")
ab.Render(r).SetCode(http.StatusOK)
})
}