feat: Add ResponseError to show error message in frontend (#14)

casdoor/permission_adapter.go

@@ -28,68 +28,71 @@ type Permission struct {
 	State       string `xorm:"varchar(100)" json:"state"`
 }
 
-func GetPermissions(owner string) []*Permission {
+func GetPermissions(owner string) ([]*Permission, error) {
 	permissions := []*Permission{}
 	err := adapter.Engine.Desc("created_time").Find(&permissions, &Permission{Owner: owner})
 	if err != nil {
-		panic(err)
+		return permissions, err
 	}
 
-	return permissions
+	return permissions, nil
 }
 
-func getPermission(owner string, name string) *Permission {
+func getPermission(owner string, name string) (*Permission, error) {
 	if owner == "" || name == "" {
-		return nil
+		return nil, nil
 	}
 
 	permission := Permission{Owner: owner, Name: name}
 	existed, err := adapter.Engine.Get(&permission)
 	if err != nil {
-		panic(err)
+		return &permission, err
 	}
 
 	if existed {
-		return &permission
+		return &permission, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }
 
-func GetPermission(id string) *Permission {
+func GetPermission(id string) (*Permission, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
 	return getPermission(owner, name)
 }
 
-func UpdatePermission(id string, permission *Permission) bool {
+func UpdatePermission(id string, permission *Permission) (bool, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
-	oldPermission := getPermission(owner, name)
+	oldPermission, err := getPermission(owner, name)
+	if err != nil {
+		return false, err
+	}
 	if oldPermission == nil {
-		return false
+		return false, nil
 	}
 
 	affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(permission)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
-func AddPermission(permission *Permission) bool {
+func AddPermission(permission *Permission) (bool, error) {
 	affected, err := adapter.Engine.Insert(permission)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
-func DeletePermission(permission *Permission) bool {
+func DeletePermission(permission *Permission) (bool, error) {
 	affected, err := adapter.Engine.ID(core.PK{permission.Owner, permission.Name}).Delete(&Permission{})
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }

controllers/file.go

@@ -19,7 +19,8 @@ func (c *ApiController) UpdateFile() {
 	var file object.File
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &file)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
 	res := object.UpdateFile(storeId, key, &file)
@@ -27,8 +28,7 @@ func (c *ApiController) UpdateFile() {
 		addRecordForFile(c, userName, "Update", storeId, key, "", true)
 	}
 
-	c.Data["json"] = res
+	c.ResponseOk(res)
-	c.ServeJSON()
 }
 
 func (c *ApiController) AddFile() {
@@ -53,14 +53,18 @@ func (c *ApiController) AddFile() {
 		defer file.Close()
 	}
 
-	res, bs := object.AddFile(storeId, key, isLeaf, filename, file)
+	res, bs, err := object.AddFile(storeId, key, isLeaf, filename, file)
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
 	if res {
 		addFileToCache(key, filename, bs)
 		addRecordForFile(c, userName, "Add", storeId, key, filename, isLeaf)
 	}
 
-	c.Data["json"] = res
+	c.ResponseOk(res)
-	c.ServeJSON()
 }
 
 func (c *ApiController) DeleteFile() {
@@ -73,11 +77,15 @@ func (c *ApiController) DeleteFile() {
 	key := c.Input().Get("key")
 	isLeaf := c.Input().Get("isLeaf") == "1"
 
-	res := object.DeleteFile(storeId, key, isLeaf)
+	res, err := object.DeleteFile(storeId, key, isLeaf)
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
 	if res {
 		addRecordForFile(c, userName, "Delete", storeId, key, "", isLeaf)
 	}
 
-	c.Data["json"] = res
+	c.ResponseOk(res)
-	c.ServeJSON()
 }

controllers/file_cache.go

@@ -53,8 +53,7 @@ func (c *ApiController) ActivateFile() {
 
 	prefix := getCachePrefix(filename)
 	if prefix == "" {
-		c.Data["json"] = false
+		c.ResponseOk(false)
-		c.ServeJSON()
 		return
 	}
 
@@ -66,8 +65,7 @@ func (c *ApiController) ActivateFile() {
 		util.CopyFile(getAppPath(filename), getAppPath(prefix))
 	}
 
-	c.Data["json"] = true
+	c.ResponseOk(true)
-	c.ServeJSON()
 }
 
 func (c *ApiController) GetActiveFile() {
@@ -78,6 +76,5 @@ func (c *ApiController) GetActiveFile() {
 		res = v
 	}
 
-	c.Data["json"] = res
+	c.ResponseOk(res)
-	c.ServeJSON()
 }

controllers/permission.go

@@ -9,15 +9,25 @@ import (
 func (c *ApiController) GetPermissions() {
 	owner := c.Input().Get("owner")
 
-	c.Data["json"] = casdoor.GetPermissions(owner)
+	permissions, err := casdoor.GetPermissions(owner)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(permissions)
 }
 
 func (c *ApiController) GetPermission() {
 	id := c.Input().Get("id")
 
-	c.Data["json"] = casdoor.GetPermission(id)
+	permission, err := casdoor.GetPermission(id)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(permission)
 }
 
 func (c *ApiController) UpdatePermission() {
@@ -29,28 +39,45 @@ func (c *ApiController) UpdatePermission() {
 		panic(err)
 	}
 
-	c.Data["json"] = casdoor.UpdatePermission(id, &permission)
+	success, err := casdoor.UpdatePermission(id, &permission)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) AddPermission() {
 	var permission casdoor.Permission
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &permission)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = casdoor.AddPermission(&permission)
+	success, err := casdoor.AddPermission(&permission)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) DeletePermission() {
 	var permission casdoor.Permission
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &permission)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = casdoor.DeletePermission(&permission)
+	success, err := casdoor.DeletePermission(&permission)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }

controllers/store.go

@@ -7,30 +7,42 @@ import (
 )
 
 func (c *ApiController) GetGlobalStores() {
-	c.Data["json"] = object.GetGlobalStores()
+	stores, err := object.GetGlobalStores()
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(stores)
 }
 
 func (c *ApiController) GetStores() {
 	owner := c.Input().Get("owner")
 
-	c.Data["json"] = object.GetStores(owner)
+	stores, err := object.GetStores(owner)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(stores)
 }
 
 func (c *ApiController) GetStore() {
 	id := c.Input().Get("id")
 
-	store := object.GetStore(id)
+	store, err := object.GetStore(id)
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
 	if store == nil {
 		c.ResponseError("store is empty")
 		return
 	}
 
 	store.Populate()
-
+	c.ResponseOk(store)
-	c.Data["json"] = store
-	c.ServeJSON()
 }
 
 func (c *ApiController) UpdateStore() {
@@ -39,31 +51,49 @@ func (c *ApiController) UpdateStore() {
 	var store object.Store
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &store)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.UpdateStore(id, &store)
+	success, err := object.UpdateStore(id, &store)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) AddStore() {
 	var store object.Store
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &store)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.AddStore(&store)
+	sucess, err := object.AddStore(&store)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(sucess)
 }
 
 func (c *ApiController) DeleteStore() {
 	var store object.Store
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &store)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.DeleteStore(&store)
+	sucess, err := object.DeleteStore(&store)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(sucess)
 }

controllers/vectorset.go

@@ -7,22 +7,37 @@ import (
 )
 
 func (c *ApiController) GetGlobalVectorsets() {
-	c.Data["json"] = object.GetGlobalVectorsets()
+	vectorsets, err := object.GetGlobalVectorsets()
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(vectorsets)
 }
 
 func (c *ApiController) GetVectorsets() {
 	owner := c.Input().Get("owner")
 
-	c.Data["json"] = object.GetVectorsets(owner)
+	vectorsets, err := object.GetVectorsets(owner)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(vectorsets)
 }
 
 func (c *ApiController) GetVectorset() {
 	id := c.Input().Get("id")
 
-	c.Data["json"] = object.GetVectorset(id)
+	vectorset, err := object.GetVectorset(id)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(vectorset)
 }
 
 func (c *ApiController) UpdateVectorset() {
@@ -31,31 +46,49 @@ func (c *ApiController) UpdateVectorset() {
 	var vectorset object.Vectorset
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &vectorset)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.UpdateVectorset(id, &vectorset)
+	success, err := object.UpdateVectorset(id, &vectorset)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) AddVectorset() {
 	var vectorset object.Vectorset
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &vectorset)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.AddVectorset(&vectorset)
+	success, err := object.AddVectorset(&vectorset)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) DeleteVectorset() {
 	var vectorset object.Vectorset
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &vectorset)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.DeleteVectorset(&vectorset)
+	success, err := object.DeleteVectorset(&vectorset)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }

controllers/video.go

@@ -13,25 +13,38 @@ import (
 )
 
 func (c *ApiController) GetGlobalVideos() {
-	c.Data["json"] = object.GetGlobalVideos()
+	videos, err := object.GetGlobalVideos()
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(videos)
 }
 
 func (c *ApiController) GetVideos() {
 	owner := c.Input().Get("owner")
 
-	c.Data["json"] = object.GetVideos(owner)
+	videos, err := object.GetVideos(owner)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(videos)
 }
 
 func (c *ApiController) GetVideo() {
 	id := c.Input().Get("id")
 
-	video := object.GetVideo(id)
+	video, err := object.GetVideo(id)
 	video.Populate()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
 
-	c.Data["json"] = video
+	c.ResponseOk(video)
-	c.ServeJSON()
 }
 
 func (c *ApiController) UpdateVideo() {
@@ -40,33 +53,51 @@ func (c *ApiController) UpdateVideo() {
 	var video object.Video
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &video)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.UpdateVideo(id, &video)
+	success, err := object.UpdateVideo(id, &video)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) AddVideo() {
 	var video object.Video
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &video)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.AddVideo(&video)
+	success, err := object.AddVideo(&video)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) DeleteVideo() {
 	var video object.Video
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &video)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.DeleteVideo(&video)
+	success, err := object.DeleteVideo(&video)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+
+	c.ResponseOk(success)
 }
 
 func startCoverUrlJob(owner string, name string, videoId string) {
@@ -74,7 +105,7 @@ func startCoverUrlJob(owner string, name string, videoId string) {
 		for i := 0; i < 20; i++ {
 			coverUrl := video.GetVideoCoverUrl(videoId)
 			if coverUrl != "" {
-				video := object.GetVideo(util.GetIdFromOwnerAndName(owner, name))
+				video, _ := object.GetVideo(util.GetIdFromOwnerAndName(owner, name))
 				if video.CoverUrl != "" {
 					break
 				}
@@ -94,7 +125,8 @@ func (c *ApiController) UploadVideo() {
 
 	file, header, err := c.GetFile("file")
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 	defer file.Close()
 

controllers/wordset.go

@@ -8,22 +8,34 @@ import (
 )
 
 func (c *ApiController) GetGlobalWordsets() {
-	c.Data["json"] = object.GetGlobalWordsets()
+	wordsets, err := object.GetGlobalWordsets()
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+	c.ResponseOk(wordsets)
 }
 
 func (c *ApiController) GetWordsets() {
 	owner := c.Input().Get("owner")
 
-	c.Data["json"] = object.GetWordsets(owner)
+	wordsets, err := object.GetWordsets(owner)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+	c.ResponseOk(wordsets)
 }
 
 func (c *ApiController) GetWordset() {
 	id := c.Input().Get("id")
 
-	c.Data["json"] = object.GetWordset(id)
+	wordset, err := object.GetWordset(id)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+	c.ResponseOk(wordset)
 }
 
 func (c *ApiController) GetWordsetGraph() {
@@ -31,15 +43,23 @@ func (c *ApiController) GetWordsetGraph() {
 	clusterNumber := util.ParseInt(c.Input().Get("clusterNumber"))
 	distanceLimit := util.ParseInt(c.Input().Get("distanceLimit"))
 
-	c.Data["json"] = object.GetWordsetGraph(id, clusterNumber, distanceLimit)
+	g, err := object.GetWordsetGraph(id, clusterNumber, distanceLimit)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+	c.ResponseOk(g)
 }
 
 func (c *ApiController) GetWordsetMatch() {
 	id := c.Input().Get("id")
 
-	c.Data["json"] = object.GetWordsetMatch(id)
+	wordset, err := object.GetWordsetMatch(id)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+	c.ResponseOk(wordset)
 }
 
 func (c *ApiController) UpdateWordset() {
@@ -48,31 +68,46 @@ func (c *ApiController) UpdateWordset() {
 	var wordset object.Wordset
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &wordset)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.UpdateWordset(id, &wordset)
+	success, err := object.UpdateWordset(id, &wordset)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) AddWordset() {
 	var wordset object.Wordset
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &wordset)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.AddWordset(&wordset)
+	success, err := object.AddWordset(&wordset)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+	c.ResponseOk(success)
 }
 
 func (c *ApiController) DeleteWordset() {
 	var wordset object.Wordset
 	err := json.Unmarshal(c.Ctx.Input.RequestBody, &wordset)
 	if err != nil {
-		panic(err)
+		c.ResponseError(err.Error())
+		return
 	}
 
-	c.Data["json"] = object.DeleteWordset(&wordset)
+	success, err := object.DeleteWordset(&wordset)
-	c.ServeJSON()
+	if err != nil {
+		c.ResponseError(err.Error())
+		return
+	}
+	c.ResponseOk(success)
 }

object/adapter.go

@@ -62,7 +62,11 @@ func (a *Adapter) createDatabase() error {
 	defer engine.Close()
 
 	_, err = engine.Exec(fmt.Sprintf("CREATE DATABASE IF NOT EXISTS %s default charset utf8 COLLATE utf8_general_ci", beego.AppConfig.String("dbName")))
-	return err
+	if err != nil {
+		return err
+	}
+
+	return nil
 }
 
 func (a *Adapter) open() {

object/file.go

@@ -14,10 +14,13 @@ func UpdateFile(storeId string, key string, file *File) bool {
 	return true
 }
 
-func AddFile(storeId string, key string, isLeaf bool, filename string, file multipart.File) (bool, []byte) {
+func AddFile(storeId string, key string, isLeaf bool, filename string, file multipart.File) (bool, []byte, error) {
-	store := GetStore(storeId)
+	store, err := GetStore(storeId)
+	if err != nil {
+		return false, nil, err
+	}
 	if store == nil {
-		return false, nil
+		return false, nil, nil
 	}
 
 	var objectKey string
@@ -26,24 +29,30 @@ func AddFile(storeId string, key string, isLeaf bool, filename string, file mult
 		objectKey = fmt.Sprintf("%s/%s", key, filename)
 		objectKey = strings.TrimLeft(objectKey, "/")
 		fileBuffer = bytes.NewBuffer(nil)
-		if _, err := io.Copy(fileBuffer, file); err != nil {
+		_, err = io.Copy(fileBuffer, file)
-			panic(err)
+		if err != nil {
+			return false, nil, err
 		}
+		bs := fileBuffer.Bytes()
+		storage.PutObject(store.Bucket, objectKey, fileBuffer)
+		return true, bs, nil
 	} else {
 		objectKey = fmt.Sprintf("%s/%s/_hidden.ini", key, filename)
 		objectKey = strings.TrimLeft(objectKey, "/")
 		fileBuffer = bytes.NewBuffer(nil)
+		bs := fileBuffer.Bytes()
+		storage.PutObject(store.Bucket, objectKey, fileBuffer)
+		return true, bs, nil
 	}
-
-	bs := fileBuffer.Bytes()
-	storage.PutObject(store.Bucket, objectKey, fileBuffer)
-	return true, bs
 }
 
-func DeleteFile(storeId string, key string, isLeaf bool) bool {
+func DeleteFile(storeId string, key string, isLeaf bool) (bool, error) {
-	store := GetStore(storeId)
+	store, err := GetStore(storeId)
+	if err != nil {
+		return false, err
+	}
 	if store == nil {
-		return false
+		return false, nil
 	}
 
 	if isLeaf {
@@ -54,5 +63,5 @@ func DeleteFile(storeId string, key string, isLeaf bool) bool {
 			storage.DeleteObject(store.Bucket, object.Key)
 		}
 	}
-	return true
+	return true, nil
 }

object/kmeans.go

@@ -59,7 +59,7 @@ func runKmeans(vectors []*Vector, clusterNumber int) {
 }
 
 func updateWordsetVectorCategories(owner string, wordsetName string) {
-	wordset := getWordset(owner, wordsetName)
+	wordset, _ := getWordset(owner, wordsetName)
 
 	runKmeans(wordset.Vectors, 100)
 

object/store.go

@@ -36,76 +36,80 @@ type Store struct {
 	PropertiesMap map[string]*Properties `xorm:"mediumtext" json:"propertiesMap"`
 }
 
-func GetGlobalStores() []*Store {
+func GetGlobalStores() ([]*Store, error) {
 	stores := []*Store{}
 	err := adapter.engine.Asc("owner").Desc("created_time").Find(&stores)
 	if err != nil {
-		panic(err)
+		return stores, err
 	}
 
-	return stores
+	return stores, nil
 }
 
-func GetStores(owner string) []*Store {
+func GetStores(owner string) ([]*Store, error) {
 	stores := []*Store{}
 	err := adapter.engine.Desc("created_time").Find(&stores, &Store{Owner: owner})
 	if err != nil {
-		panic(err)
+		return stores, err
 	}
 
-	return stores
+	return stores, nil
 }
 
-func getStore(owner string, name string) *Store {
+func getStore(owner string, name string) (*Store, error) {
 	store := Store{Owner: owner, Name: name}
 	existed, err := adapter.engine.Get(&store)
 	if err != nil {
-		panic(err)
+		return &store, err
 	}
 
 	if existed {
-		return &store
+		return &store, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }
 
-func GetStore(id string) *Store {
+func GetStore(id string) (*Store, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
 	return getStore(owner, name)
 }
 
-func UpdateStore(id string, store *Store) bool {
+func UpdateStore(id string, store *Store) (bool, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
-	if getStore(owner, name) == nil {
+	_, err := getStore(owner, name)
-		return false
+	if err != nil {
+		return false, err
+	}
+	if store == nil {
+		return false, nil
 	}
 
-	_, err := adapter.engine.ID(core.PK{owner, name}).AllCols().Update(store)
+	_, err = adapter.engine.ID(core.PK{owner, name}).AllCols().Update(store)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
 	//return affected != 0
-	return true
+	return true, nil
 }
 
-func AddStore(store *Store) bool {
+func AddStore(store *Store) (bool, error) {
 	affected, err := adapter.engine.Insert(store)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
-func DeleteStore(store *Store) bool {
+func DeleteStore(store *Store) (bool, error) {
 	affected, err := adapter.engine.ID(core.PK{store.Owner, store.Name}).Delete(&Store{})
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
 func (store *Store) GetId() string {

object/store_test.go

@@ -5,7 +5,7 @@ import "testing"
 func TestUpdateStoreFolders(t *testing.T) {
 	InitConfig()
 
-	store := getStore("admin", "default")
+	store, _ := getStore("admin", "default")
 	//store.Populate()
 	store.GetVideoData()
 }

object/vectorset.go

@@ -24,76 +24,80 @@ type Vectorset struct {
 	VectorMap  map[string]*Vector `xorm:"-" json:"vectorMap"`
 }
 
-func GetGlobalVectorsets() []*Vectorset {
+func GetGlobalVectorsets() ([]*Vectorset, error) {
 	vectorsets := []*Vectorset{}
 	err := adapter.engine.Asc("owner").Desc("created_time").Find(&vectorsets)
 	if err != nil {
-		panic(err)
+		return vectorsets, err
 	}
 
-	return vectorsets
+	return vectorsets, nil
 }
 
-func GetVectorsets(owner string) []*Vectorset {
+func GetVectorsets(owner string) ([]*Vectorset, error) {
 	vectorsets := []*Vectorset{}
 	err := adapter.engine.Desc("created_time").Find(&vectorsets, &Vectorset{Owner: owner})
 	if err != nil {
-		panic(err)
+		return vectorsets, err
 	}
 
-	return vectorsets
+	return vectorsets, nil
 }
 
-func getVectorset(owner string, name string) *Vectorset {
+func getVectorset(owner string, name string) (*Vectorset, error) {
 	vectorset := Vectorset{Owner: owner, Name: name}
 	existed, err := adapter.engine.Get(&vectorset)
 	if err != nil {
-		panic(err)
+		return &vectorset, err
 	}
 
 	if existed {
-		return &vectorset
+		return &vectorset, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }
 
-func GetVectorset(id string) *Vectorset {
+func GetVectorset(id string) (*Vectorset, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
 	return getVectorset(owner, name)
 }
 
-func UpdateVectorset(id string, vectorset *Vectorset) bool {
+func UpdateVectorset(id string, vectorset *Vectorset) (bool, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
-	if getVectorset(owner, name) == nil {
+	_, err := getVectorset(owner, name)
-		return false
+	if err != nil {
+		return false, err
+	}
+	if vectorset == nil {
+		return false, nil
 	}
 
-	_, err := adapter.engine.ID(core.PK{owner, name}).AllCols().Update(vectorset)
+	_, err = adapter.engine.ID(core.PK{owner, name}).AllCols().Update(vectorset)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
 	//return affected != 0
-	return true
+	return true, nil
 }
 
-func AddVectorset(vectorset *Vectorset) bool {
+func AddVectorset(vectorset *Vectorset) (bool, error) {
 	affected, err := adapter.engine.Insert(vectorset)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
-func DeleteVectorset(vectorset *Vectorset) bool {
+func DeleteVectorset(vectorset *Vectorset) (bool, error) {
 	affected, err := adapter.engine.ID(core.PK{vectorset.Owner, vectorset.Name}).Delete(&Vectorset{})
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
 func (vectorset *Vectorset) GetId() string {

object/vectorset_tsne_test.go

@@ -11,7 +11,7 @@ func TestDoVectorsetTsne(t *testing.T) {
 	dimension := 50
 
 	//vectorset := getVectorset("admin", "wikipedia")
-	vectorset := getVectorset("admin", "wordVector_utf-8")
+	vectorset, _ := getVectorset("admin", "wordVector_utf-8")
 	vectorset.LoadVectors("../../tmpFiles/")
 	vectorset.DoTsne(dimension)
 

object/vectorset_upload_test.go

@@ -6,7 +6,7 @@ func TestUpdateVectorsetVectors(t *testing.T) {
 	InitConfig()
 
 	//vectorset := getVectorset("admin", "wikipedia")
-	vectorset := getVectorset("admin", "wordVector_utf-8")
+	vectorset, _ := getVectorset("admin", "wordVector_utf-8")
 	vectorset.LoadVectors("../../tmpFiles/")
 	UpdateVectorset(vectorset.GetId(), vectorset)
 }

object/video.go

@@ -31,79 +31,83 @@ type Video struct {
 	PlayAuth string `xorm:"-" json:"playAuth"`
 }
 
-func GetGlobalVideos() []*Video {
+func GetGlobalVideos() ([]*Video, error) {
 	videos := []*Video{}
 	err := adapter.engine.Asc("owner").Desc("created_time").Find(&videos)
 	if err != nil {
-		panic(err)
+		return videos, err
 	}
 
-	return videos
+	return videos, nil
 }
 
-func GetVideos(owner string) []*Video {
+func GetVideos(owner string) ([]*Video, error) {
 	videos := []*Video{}
 	err := adapter.engine.Desc("created_time").Find(&videos, &Video{Owner: owner})
 	if err != nil {
-		panic(err)
+		return videos, err
 	}
 
-	return videos
+	return videos, nil
 }
 
-func getVideo(owner string, name string) *Video {
+func getVideo(owner string, name string) (*Video, error) {
 	v := Video{Owner: owner, Name: name}
 	existed, err := adapter.engine.Get(&v)
 	if err != nil {
-		panic(err)
+		return &v, err
 	}
 
 	if existed {
 		if v.VideoId != "" {
 			v.PlayAuth = video.GetVideoPlayAuth(v.VideoId)
 		}
-		return &v
+		return &v, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }
 
-func GetVideo(id string) *Video {
+func GetVideo(id string) (*Video, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
 	return getVideo(owner, name)
 }
 
-func UpdateVideo(id string, video *Video) bool {
+func UpdateVideo(id string, video *Video) (bool, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
-	if getVideo(owner, name) == nil {
+	_, err := getVideo(owner, name)
-		return false
+	if err != nil {
+		return false, err
+	}
+	if video == nil {
+		return false, nil
 	}
 
-	_, err := adapter.engine.ID(core.PK{owner, name}).AllCols().Update(video)
+	_, err = adapter.engine.ID(core.PK{owner, name}).AllCols().Update(video)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
 	//return affected != 0
-	return true
+	return true, nil
 }
 
-func AddVideo(video *Video) bool {
+func AddVideo(video *Video) (bool, error) {
 	affected, err := adapter.engine.Insert(video)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
-func DeleteVideo(video *Video) bool {
+func DeleteVideo(video *Video) (bool, error) {
 	affected, err := adapter.engine.ID(core.PK{video.Owner, video.Name}).Delete(&Video{})
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
 func (video *Video) GetId() string {
@@ -111,6 +115,6 @@ func (video *Video) GetId() string {
 }
 
 func (video *Video) Populate() {
-	store := getStore("admin", "default")
+	store, _ := getStore("admin", "default")
 	video.DataUrls = store.GetVideoData()
 }

object/wordset.go

@@ -19,76 +19,80 @@ type Wordset struct {
 	Vectors []*Vector `xorm:"mediumtext" json:"vectors"`
 }
 
-func GetGlobalWordsets() []*Wordset {
+func GetGlobalWordsets() ([]*Wordset, error) {
 	wordsets := []*Wordset{}
 	err := adapter.engine.Asc("owner").Desc("created_time").Find(&wordsets)
 	if err != nil {
-		panic(err)
+		return wordsets, err
 	}
 
-	return wordsets
+	return wordsets, nil
 }
 
-func GetWordsets(owner string) []*Wordset {
+func GetWordsets(owner string) ([]*Wordset, error) {
 	wordsets := []*Wordset{}
 	err := adapter.engine.Desc("created_time").Find(&wordsets, &Wordset{Owner: owner})
 	if err != nil {
-		panic(err)
+		return wordsets, err
 	}
 
-	return wordsets
+	return wordsets, nil
 }
 
-func getWordset(owner string, name string) *Wordset {
+func getWordset(owner string, name string) (*Wordset, error) {
 	wordset := Wordset{Owner: owner, Name: name}
 	existed, err := adapter.engine.Get(&wordset)
 	if err != nil {
-		panic(err)
+		return &wordset, err
 	}
 
 	if existed {
-		return &wordset
+		return &wordset, nil
 	} else {
-		return nil
+		return nil, nil
 	}
 }
 
-func GetWordset(id string) *Wordset {
+func GetWordset(id string) (*Wordset, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
 	return getWordset(owner, name)
 }
 
-func UpdateWordset(id string, wordset *Wordset) bool {
+func UpdateWordset(id string, wordset *Wordset) (bool, error) {
 	owner, name := util.GetOwnerAndNameFromId(id)
-	if getWordset(owner, name) == nil {
+	_, err := getWordset(owner, name)
-		return false
+	if err != nil {
+		return false, err
+	}
+	if wordset == nil {
+		return false, nil
 	}
 
-	_, err := adapter.engine.ID(core.PK{owner, name}).AllCols().Update(wordset)
+	_, err = adapter.engine.ID(core.PK{owner, name}).AllCols().Update(wordset)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
 	//return affected != 0
-	return true
+	return true, nil
 }
 
-func AddWordset(wordset *Wordset) bool {
+func AddWordset(wordset *Wordset) (bool, error) {
 	affected, err := adapter.engine.Insert(wordset)
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
-func DeleteWordset(wordset *Wordset) bool {
+func DeleteWordset(wordset *Wordset) (bool, error) {
 	affected, err := adapter.engine.ID(core.PK{wordset.Owner, wordset.Name}).Delete(&Wordset{})
 	if err != nil {
-		panic(err)
+		return false, err
 	}
 
-	return affected != 0
+	return affected != 0, nil
 }
 
 func (wordset *Wordset) GetId() string {

object/wordset_graph.go

@@ -15,21 +15,24 @@ func init() {
 	graphCache = map[string]*Graph{}
 }
 
-func GetWordsetGraph(id string, clusterNumber int, distanceLimit int) *Graph {
+func GetWordsetGraph(id string, clusterNumber int, distanceLimit int) (*Graph, error) {
 	cacheId := fmt.Sprintf("%s|%d|%d", id, clusterNumber, distanceLimit)
 
 	g, ok := graphCache[cacheId]
 	if ok {
-		return g
+		return g, nil
 	}
 
-	wordset := GetWordset(id)
+	wordset, err := GetWordset(id)
+	if err != nil {
+		return nil, err
+	}
 	if wordset == nil {
-		return nil
+		return nil, nil
 	}
 
 	if len(wordset.Vectors) == 0 {
-		return nil
+		return nil, nil
 	}
 
 	allZero := true
@@ -40,14 +43,14 @@ func GetWordsetGraph(id string, clusterNumber int, distanceLimit int) *Graph {
 		}
 	}
 	if allZero {
-		return nil
+		return nil, nil
 	}
 
 	runKmeans(wordset.Vectors, clusterNumber)
 
 	g = generateGraph(wordset.Vectors, distanceLimit)
 	//graphCache[cacheId] = g
-	return g
+	return g, nil
 }
 
 func getDistance(v1 *Vector, v2 *Vector) float64 {

object/wordset_match.go

@@ -1,14 +1,20 @@
 package object
 
-func GetWordsetMatch(id string) *Wordset {
+func GetWordsetMatch(id string) (*Wordset, error) {
-	wordset := GetWordset(id)
+	wordset, err := GetWordset(id)
+	if err != nil {
+		return nil, err
+	}
 	if wordset == nil {
-		return nil
+		return nil, nil
 	}
 
-	vectorset := getVectorset(wordset.Owner, wordset.Vectorset)
+	vectorset, err := getVectorset(wordset.Owner, wordset.Vectorset)
+	if err != nil {
+		return nil, err
+	}
 	if vectorset == nil {
-		return nil
+		return nil, nil
 	}
 
 	vectorset.LoadVectors("")
@@ -22,5 +28,5 @@ func GetWordsetMatch(id string) *Wordset {
 	}
 
 	UpdateWordset(wordset.GetId(), wordset)
-	return wordset
+	return wordset, nil
 }

object/wordset_upload.go

@@ -5,7 +5,7 @@ import (
 	"github.com/casbin/casibase/xlsx"
 )
 
-func uploadVectorNames(owner string, fileId string) bool {
+func uploadVectorNames(owner string, fileId string) (bool, error) {
 	table := xlsx.ReadXlsxFile(fileId)
 
 	vectorMap := map[string]int{}

web/src/App.js

@@ -95,14 +95,18 @@ class App extends Component {
   getAccount() {
     AccountBackend.getAccount()
       .then((res) => {
-        const account = res.data;
+        if (res.status === "ok") {
-        if (account !== null) {
+          const account = res.data;
-          this.setLanguage(account);
+          if (account !== null) {
+            this.setLanguage(account);
+          }
+          this.setState({
+            account: account,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get account: ${res.msg}`);
+          Setting.goToLink("/signin");
         }
-
-        this.setState({
-          account: account,
-        });
       });
   }
 

web/src/ClusteringPage.js

@@ -2,6 +2,7 @@ import React from "react";
 import * as Conf from "./Conf";
 import * as WordsetBackend from "./backend/WordsetBackend";
 import WordsetGraph from "./WordsetGraph";
+import * as Setting from "./Setting";
 
 class ClusteringPage extends React.Component {
   constructor(props) {
@@ -19,9 +20,11 @@ class ClusteringPage extends React.Component {
   getWordset() {
     WordsetBackend.getWordset(Conf.DefaultOwner, Conf.DefaultWordsetName)
       .then((wordset) => {
-        this.setState({
+        if (wordset.status === "ok") {
-          wordset: wordset,
+          this.setState({wordset: wordset.data});
-        });
+        } else {
+          Setting.showMessage("error", `Failed to get wordset: ${wordset.msg}`);
+        }
       });
   }
 

web/src/FileTable.js

@@ -65,11 +65,15 @@ class FileTable extends React.Component {
     const storeId = `${this.props.store.owner}/${this.props.store.name}`;
     FileBackend.deleteFile(storeId, file.key, isLeaf)
       .then((res) => {
-        if (res === true) {
+        if (res.status === "ok") {
-          Setting.showMessage("success", "File deleted successfully");
+          if (res.data === true) {
-          this.props.onRefresh();
+            Setting.showMessage("success", "File deleted successfully");
+            this.props.onRefresh();
+          } else {
+            Setting.showMessage("error", `File failed to delete: ${res.msg}`);
+          }
         } else {
-          Setting.showMessage("error", `File failed to delete: ${res}`);
+          Setting.showMessage("error", `File failed to delete: ${res.msg}`);
         }
       })
       .catch(error => {

web/src/FileTree.js

@@ -68,11 +68,15 @@ class FileTree extends React.Component {
   getPermissions() {
     PermissionBackend.getPermissions(Conf.AuthConfig.organizationName)
       .then((permissions) => {
-        permissions = permissions.filter(permission => (permission.domains[0] === this.props.store.name) && permission.users.length !== 0);
+        if (permissions.status === "ok") {
-        this.setState({
+          permissions = permissions.filter(permission => (permission.domains[0] === this.props.store.name) && permission.users.length !== 0);
-          permissions: permissions,
+          this.setState({
-          permissionMap: this.getPermissionMap(permissions),
+            permissions: permissions,
-        });
+            permissionMap: this.getPermissionMap(permissions),
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get permissions: ${permissions.msg}`);
+        }
       });
   }
 
@@ -164,8 +168,12 @@ class FileTree extends React.Component {
     const storeId = `${this.props.store.owner}/${this.props.store.name}`;
     FileBackend.addFile(storeId, file.key, false, newFolder, null)
       .then((res) => {
-        Setting.showMessage("success", "File added successfully");
+        if (res.status === "ok") {
-        this.props.onRefresh();
+          Setting.showMessage("success", "File added successfully");
+          this.props.onRefresh();
+        } else {
+          Setting.showMessage("error", `File failed to add: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `File failed to add: ${error}`);
@@ -176,11 +184,15 @@ class FileTree extends React.Component {
     const storeId = `${this.props.store.owner}/${this.props.store.name}`;
     FileBackend.deleteFile(storeId, file.key, isLeaf)
       .then((res) => {
-        if (res === true) {
+        if (res.status === "ok") {
-          Setting.showMessage("success", "File deleted successfully");
+          if (res.data === true) {
-          this.props.onRefresh();
+            Setting.showMessage("success", "File deleted successfully");
+            this.props.onRefresh();
+          } else {
+            Setting.showMessage("error", "File failed to delete：server side failure");
+          }
         } else {
-          Setting.showMessage("error", `File failed to delete: ${res}`);
+          Setting.showMessage("error", `File failed to delete: ${res.msg}`);
         }
       })
       .catch(error => {
@@ -334,11 +346,15 @@ class FileTree extends React.Component {
         if (this.getCacheApp(filename) !== "") {
           FileBackend.activateFile(key, filename)
             .then((res) => {
-              if (res === true) {
+              if (res.status === "ok") {
-                // Setting.showMessage("success", `File activated successfully`);
+                if (res.data === true) {
-                fetchFile();
+                  // Setting.showMessage("success", `File activated successfully`);
+                  fetchFile();
+                } else {
+                  Setting.showMessage("error", "File failed to activate: server side failure");
+                }
               } else {
-                Setting.showMessage("error", `File failed to activate: ${res}`);
+                Setting.showMessage("error", `File failed to activate: ${res.msg}`);
               }
             })
             .catch(error => {

web/src/FileTreePage.js

@@ -25,7 +25,7 @@ class FileTreePage extends React.Component {
       .then((res) => {
         if (res?.status !== "error") {
           this.setState({
-            store: res,
+            store: res.data,
           });
         } else {
           Setting.showMessage("error", res.msg);

web/src/LabelTable.js

@@ -3,8 +3,6 @@ import {DeleteOutlined} from "@ant-design/icons";
 import {Button, Col, Input, InputNumber, Row, Table, Tooltip} from "antd";
 import * as Setting from "./Setting";
 import i18next from "i18next";
-import FileSaver from "file-saver";
-import XLSX from "xlsx";
 
 class LabelTable extends React.Component {
   constructor(props) {
@@ -73,23 +71,6 @@ class LabelTable extends React.Component {
     this.updateTable(table);
   }
 
-  downloadLabels(table) {
-    const data = [];
-    table.forEach((label, i) => {
-      const row = {};
-
-      row[0] = label.startTime;
-      row[1] = label.endTime;
-      row[2] = label.text;
-      data.push(row);
-    });
-
-    const sheet = XLSX.utils.json_to_sheet(data, {skipHeader: true});
-    const blob = Setting.sheet2blob(sheet, "labels");
-    const fileName = `labels-${this.props.video.name}-${table.length}.xlsx`;
-    FileSaver.saveAs(blob, fileName);
-  }
-
   renderTable(table) {
     const columns = [
       {
@@ -194,7 +175,7 @@ class LabelTable extends React.Component {
             <Button style={{marginRight: "5px"}} type="primary" size="small" onClick={() => this.addRow(table)}>{i18next.t("general:Add")}</Button>
             {
               table.length === 0 ? null : (
-                <Button style={{marginLeft: "5px", marginRight: "5px"}} size="small" onClick={() => this.downloadLabels(table)}>{i18next.t("general:Download")}</Button>
+                <Button style={{marginLeft: "5px", marginRight: "5px"}} size="small" onClick={() => Setting.downloadLabels(table)}>{i18next.t("general:Download")}</Button>
               )
             }
           </div>

web/src/PermissionUtil.js

@@ -35,9 +35,12 @@ export function addPermission(account, store, file = null, fileKeys = null) {
 
   PermissionBackend.addPermission(newPermission)
     .then((res) => {
-      Setting.openLink(Setting.getMyProfileUrl(account).replace("/account", `/permissions/${newPermission.owner}/${newPermission.name}`));
+      if (res.status === "ok") {
-    }
+        Setting.openLink(Setting.getMyProfileUrl(account).replace("/account", `/permissions/${newPermission.owner}/${newPermission.name}`));
-    )
+      } else {
+        Setting.showMessage("error", `Permission failed to add: ${res.msg}`);
+      }
+    })
     .catch(error => {
       Setting.showMessage("error", `Permission failed to add: ${error}`);
     });

web/src/Setting.js

@@ -102,6 +102,9 @@ export function isLocalAdminUser(account) {
 }
 
 export function deepCopy(obj) {
+  if (obj === null) {
+    showMessage("error", "deepCopy obj is null.");
+  }
   return Object.assign({}, obj);
 }
 
@@ -371,11 +374,50 @@ export function downloadXlsx(wordset) {
   //   { wch: 7 },
   // ];
 
-  const blob = sheet2blob(sheet, "vectors");
+  try {
-  const fileName = `vectors-${wordset.name}.xlsx`;
+    const blob = sheet2blob(sheet, "vectors");
-  FileSaver.saveAs(blob, fileName);
+    const fileName = `vectors-${wordset.name}.xlsx`;
+    FileSaver.saveAs(blob, fileName);
+  } catch (error) {
+    showMessage("error", `failed to download: ${error.message}`);
+  }
 }
 
+export function downloadLabels(table) {
+  const data = [];
+  table.forEach((label, i) => {
+    const row = {};
+
+    row[0] = label.startTime;
+    row[1] = label.endTime;
+    row[2] = label.text;
+    data.push(row);
+  });
+
+  const sheet = XLSX.utils.json_to_sheet(data, {skipHeader: true});
+  try {
+    const blob = sheet2blob(sheet, "labels");
+    const fileName = `labels-${this.props.video.name}-${table.length}.xlsx`;
+    FileSaver.saveAs(blob, fileName);
+  } catch (error) {
+    showMessage("error", `failed to download: ${error.message}`);
+  }
+}
+
+export const redirectCatchJsonError = async(url) => {
+  try {
+    const response = await fetch(url);
+    const msg = await response.json();
+    if (response.ok) {
+      this.props.history.push(url);
+    } else {
+      showMessage("error", `error in redirect: ${msg}`);
+    }
+  } catch (error) {
+    showMessage("error", `failed to redirect: ${error.message}`);
+  }
+};
+
 export function toFixed(f, n) {
   return parseFloat(f.toFixed(n));
 }
@@ -498,10 +540,14 @@ export function submitStoreEdit(storeObj) {
   store.fileTree = undefined;
   StoreBackend.updateStore(storeObj.owner, storeObj.name, store)
     .then((res) => {
-      if (res) {
+      if (res.status === "ok") {
-        showMessage("success", "Successfully saved");
+        if (res.data) {
+          showMessage("success", "Successfully saved");
+        } else {
+          showMessage("error", "failed to save: server side failure");
+        }
       } else {
-        showMessage("error", "failed to save: server side failure");
+        showMessage("error", `failed to save: ${res.msg}`);
       }
     })
     .catch(error => {

web/src/StoreEditPage.js

@@ -24,9 +24,13 @@ class StoreEditPage extends React.Component {
   getStore() {
     StoreBackend.getStore(this.state.owner, this.state.storeName)
       .then((store) => {
-        this.setState({
+        if (store.status === "ok") {
-          store: store,
+          this.setState({
-        });
+            store: store.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get store: ${store.msg}`);
+        }
       });
   }
 
@@ -117,15 +121,19 @@ class StoreEditPage extends React.Component {
     store.fileTree = undefined;
     StoreBackend.updateStore(this.state.store.owner, this.state.storeName, store)
       .then((res) => {
-        if (res) {
+        if (res.status === "ok") {
-          Setting.showMessage("success", "Successfully saved");
+          if (res.data) {
-          this.setState({
+            Setting.showMessage("success", "Successfully saved");
-            storeName: this.state.store.name,
+            this.setState({
-          });
+              storeName: this.state.store.name,
-          this.props.history.push(`/stores/${this.state.store.owner}/${this.state.store.name}`);
+            });
+            this.props.history.push(`/stores/${this.state.store.owner}/${this.state.store.name}`);
+          } else {
+            Setting.showMessage("error", "failed to save: server side failure");
+            this.updateStoreField("name", this.state.storeName);
+          }
         } else {
-          Setting.showMessage("error", "failed to save: server side failure");
+          Setting.showMessage("error", `failed to save: ${res.msg}`);
-          this.updateStoreField("name", this.state.storeName);
         }
       })
       .catch(error => {

web/src/StoreListPage.js

@@ -22,9 +22,13 @@ class StoreListPage extends React.Component {
   getStores() {
     StoreBackend.getGlobalStores()
       .then((res) => {
-        this.setState({
+        if (res.status === "ok") {
-          stores: res,
+          this.setState({
-        });
+            stores: res.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get stores: ${res.msg}`);
+        }
       });
   }
 
@@ -44,10 +48,14 @@ class StoreListPage extends React.Component {
     const newStore = this.newStore();
     StoreBackend.addStore(newStore)
       .then((res) => {
-        Setting.showMessage("success", "Store added successfully");
+        if (res.status === "ok") {
-        this.setState({
+          Setting.showMessage("success", "Store added successfully");
-          stores: Setting.prependRow(this.state.stores, newStore),
+          this.setState({
-        });
+            stores: Setting.prependRow(this.state.stores, newStore),
+          });
+        } else {
+          Setting.showMessage("error", `Store failed to add: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `Store failed to add: ${error}`);
@@ -57,10 +65,14 @@ class StoreListPage extends React.Component {
   deleteStore(i) {
     StoreBackend.deleteStore(this.state.stores[i])
       .then((res) => {
-        Setting.showMessage("success", "Store deleted successfully");
+        if (res.status === "ok") {
-        this.setState({
+          Setting.showMessage("success", "Store deleted successfully");
-          stores: Setting.deleteRow(this.state.stores, i),
+          this.setState({
-        });
+            stores: Setting.deleteRow(this.state.stores, i),
+          });
+        } else {
+          Setting.showMessage("error", `Store failed to delete: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `Store failed to delete: ${error}`);
@@ -98,12 +110,19 @@ class StoreListPage extends React.Component {
         render: (text, record, index) => {
           return (
             <div>
-              <Button style={{marginTop: "10px", marginBottom: "10px", marginRight: "10px"}} onClick={() => this.props.history.push(`/stores/${record.owner}/${record.name}/view`)}>{i18next.t("general:View")}</Button>
+              <Button
+                style={{marginTop: "10px", marginBottom: "10px", marginRight: "10px"}}
+                onClick={() => Setting.redirectCatchJsonError(`/stores/${record.owner}/${record.name}/view`)}
+              >
+                {i18next.t("general:View")}
+              </Button>
               {
                 !Setting.isLocalAdminUser(this.props.account) ? null : (
                   <React.Fragment>
-                    <Button style={{marginBottom: "10px", marginRight: "10px"}} type="primary" onClick={() => this.props.history.push(`/stores/${record.owner}/${record.name}`)}>{i18next.t("general:Edit")}</Button>
+                    <Button style={{marginBottom: "10px", marginRight: "10px"}} type="primary" onClick={
-                    <Popconfirm
+                      () => Setting.redirectCatchJsonError(`/stores/${record.owner}/${record.name}`)}
+                    >{i18next.t("general:Edit")}
+                    </Button>                    <Popconfirm
                       title={`Sure to delete store: ${record.name} ?`}
                       onConfirm={() => this.deleteStore(index)}
                       okText="OK"

web/src/VectorsetEditPage.js

@@ -23,9 +23,13 @@ class VectorsetEditPage extends React.Component {
   getVectorset() {
     VectorsetBackend.getVectorset(this.props.account.name, this.state.vectorsetName)
       .then((vectorset) => {
-        this.setState({
+        if (vectorset.status === "ok") {
-          vectorset: vectorset,
+          this.setState({
-        });
+            vectorset: vectorset.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get vectorset: ${vectorset.msg}`);
+        }
       });
   }
 
@@ -144,15 +148,19 @@ class VectorsetEditPage extends React.Component {
     const vectorset = Setting.deepCopy(this.state.vectorset);
     VectorsetBackend.updateVectorset(this.state.vectorset.owner, this.state.vectorsetName, vectorset)
       .then((res) => {
-        if (res) {
+        if (res.status === "ok") {
-          Setting.showMessage("success", "Successfully saved");
+          if (res.data) {
-          this.setState({
+            Setting.showMessage("success", "Successfully saved");
-            vectorsetName: this.state.vectorset.name,
+            this.setState({
-          });
+              vectorsetName: this.state.vectorset.name,
-          this.props.history.push(`/vectorsets/${this.state.vectorset.name}`);
+            });
+            this.props.history.push(`/vectorsets/${this.state.vectorset.name}`);
+          } else {
+            Setting.showMessage("error", "failed to save: server side failure");
+            this.updateVectorsetField("name", this.state.vectorsetName);
+          }
         } else {
-          Setting.showMessage("error", "failed to save: server side failure");
+          Setting.showMessage("error", `failed to save: ${res.msg}`);
-          this.updateVectorsetField("name", this.state.vectorsetName);
         }
       })
       .catch(error => {

web/src/VectorsetListPage.js

@@ -22,9 +22,13 @@ class VectorsetListPage extends React.Component {
   getVectorsets() {
     VectorsetBackend.getVectorsets(this.props.account.name)
       .then((res) => {
-        this.setState({
+        if (res.status === "ok") {
-          vectorsets: res,
+          this.setState({
-        });
+            vectorsets: res.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get vectorsets: ${res.msg}`);
+        }
       });
   }
 
@@ -47,10 +51,14 @@ class VectorsetListPage extends React.Component {
     const newVectorset = this.newVectorset();
     VectorsetBackend.addVectorset(newVectorset)
       .then((res) => {
-        Setting.showMessage("success", "Vectorset added successfully");
+        if (res.status === "ok") {
-        this.setState({
+          Setting.showMessage("success", "Vectorset added successfully");
-          vectorsets: Setting.prependRow(this.state.vectorsets, newVectorset),
+          this.setState({
-        });
+            vectorsets: Setting.prependRow(this.state.vectorsets, newVectorset),
+          });
+        } else {
+          Setting.showMessage("error", `Failed to add vectorset: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `Vectorset failed to add: ${error}`);
@@ -60,10 +68,14 @@ class VectorsetListPage extends React.Component {
   deleteVectorset(i) {
     VectorsetBackend.deleteVectorset(this.state.vectorsets[i])
       .then((res) => {
-        Setting.showMessage("success", "Vectorset deleted successfully");
+        if (res.status === "ok") {
-        this.setState({
+          Setting.showMessage("success", "Vectorset deleted successfully");
-          vectorsets: Setting.deleteRow(this.state.vectorsets, i),
+          this.setState({
-        });
+            vectorsets: Setting.deleteRow(this.state.vectorsets, i),
+          });
+        } else {
+          Setting.showMessage("error", `Vectorset failed to delete: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `Vectorset failed to delete: ${error}`);

web/src/VideoEditPage.js

@@ -34,13 +34,17 @@ class VideoEditPage extends React.Component {
   getVideo() {
     VideoBackend.getVideo(this.props.account.name, this.state.videoName)
       .then((video) => {
-        this.setState({
+        if (video.status === "ok") {
-          video: video,
+          this.setState({
-          currentTime: 0,
+            video: video.data,
-        });
+            currentTime: 0,
+          });
 
-        if (video.dataUrl !== "") {
+          if (video.dataUrl !== "") {
-          this.getDataAndParse(video.dataUrl);
+            this.getDataAndParse(video.dataUrl);
+          }
+        } else {
+          Setting.showMessage("error", `Failed to get video: ${video.msg}`);
         }
       });
   }
@@ -265,15 +269,19 @@ class VideoEditPage extends React.Component {
     const video = Setting.deepCopy(this.state.video);
     VideoBackend.updateVideo(this.state.video.owner, this.state.videoName, video)
       .then((res) => {
-        if (res) {
+        if (res.status === "ok") {
-          Setting.showMessage("success", "Successfully saved");
+          if (res.data) {
-          this.setState({
+            Setting.showMessage("success", "Successfully saved");
-            videoName: this.state.video.name,
+            this.setState({
-          });
+              videoName: this.state.video.name,
-          this.props.history.push(`/videos/${this.state.video.name}`);
+            });
+            this.props.history.push(`/videos/${this.state.video.name}`);
+          } else {
+            Setting.showMessage("error", "failed to save: server side failure");
+            this.updateVideoField("name", this.state.videoName);
+          }
         } else {
-          Setting.showMessage("error", "failed to save: server side failure");
+          Setting.showMessage("error", `failed to save: ${res.msg}`);
-          this.updateVideoField("name", this.state.videoName);
         }
       })
       .catch(error => {

web/src/VideoListPage.js

@@ -23,9 +23,13 @@ class VideoListPage extends React.Component {
   getVideos() {
     VideoBackend.getVideos(this.props.account.name)
       .then((res) => {
-        this.setState({
+        if (res.status === "ok") {
-          videos: res,
+          this.setState({
-        });
+            videos: res.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get videos: ${res.msg}`);
+        }
       });
   }
 
@@ -48,10 +52,14 @@ class VideoListPage extends React.Component {
     const newVideo = this.newVideo();
     VideoBackend.addVideo(newVideo)
       .then((res) => {
-        Setting.showMessage("success", "Video added successfully");
+        if (res.status === "ok") {
-        this.setState({
+          Setting.showMessage("success", "Video added successfully");
-          videos: Setting.prependRow(this.state.videos, newVideo),
+          this.setState({
-        });
+            videos: Setting.prependRow(this.state.videos, newVideo),
+          });
+        } else {
+          Setting.showMessage("error", `Video failed to add: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `Video failed to add: ${error}`);
@@ -61,10 +69,14 @@ class VideoListPage extends React.Component {
   deleteVideo(i) {
     VideoBackend.deleteVideo(this.state.videos[i])
       .then((res) => {
-        Setting.showMessage("success", "Video deleted successfully");
+        if (res.status === "ok") {
-        this.setState({
+          Setting.showMessage("success", "Video deleted successfully");
-          videos: Setting.deleteRow(this.state.videos, i),
+          this.setState({
-        });
+            videos: Setting.deleteRow(this.state.videos, i),
+          });
+        } else {
+          Setting.showMessage("error", `Video failed to delete: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `Video failed to delete: ${error}`);

web/src/WordsetEditPage.js

@@ -29,18 +29,26 @@ class WordsetEditPage extends React.Component {
   getWordset() {
     WordsetBackend.getWordset(this.props.account.name, this.state.wordsetName)
       .then((wordset) => {
-        this.setState({
+        if (wordset.status === "ok") {
-          wordset: wordset,
+          this.setState({
-        });
+            wordset: wordset.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get wordset: ${wordset.msg}`);
+        }
       });
   }
 
   getVectorsets() {
     VectorsetBackend.getVectorsets(this.props.account.name)
       .then((res) => {
-        this.setState({
+        if (res.status === "ok") {
-          vectorsets: res,
+          this.setState({
-        });
+            vectorsets: res.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get vectorsets: ${res.msg}`);
+        }
       });
   }
 
@@ -115,10 +123,14 @@ class WordsetEditPage extends React.Component {
               });
               WordsetBackend.getWordsetMatch(this.props.account.name, this.state.wordsetName)
                 .then((wordset) => {
-                  this.setState({
+                  if (wordset.status === "ok") {
-                    wordset: wordset,
+                    this.setState({
-                    matchLoading: false,
+                      wordset: wordset.data,
-                  });
+                      matchLoading: false,
+                    });
+                  } else {
+                    Setting.showMessage("error", `Failed to get wordset: ${wordset.msg}`);
+                  }
                 });
             }}>{i18next.t("wordset:Match")}</Button>
           </Col>
@@ -170,15 +182,19 @@ class WordsetEditPage extends React.Component {
     const wordset = Setting.deepCopy(this.state.wordset);
     WordsetBackend.updateWordset(this.state.wordset.owner, this.state.wordsetName, wordset)
       .then((res) => {
-        if (res) {
+        if (res.status === "ok") {
-          Setting.showMessage("success", "Successfully saved");
+          if (res.data) {
-          this.setState({
+            Setting.showMessage("success", "Successfully saved");
-            wordsetName: this.state.wordset.name,
+            this.setState({
-          });
+              wordsetName: this.state.wordset.name,
-          this.props.history.push(`/wordsets/${this.state.wordset.name}`);
+            });
+            this.props.history.push(`/wordsets/${this.state.wordset.name}`);
+          } else {
+            Setting.showMessage("error", "failed to save: server side failure");
+            this.updateWordsetField("name", this.state.wordsetName);
+          }
         } else {
-          Setting.showMessage("error", "failed to save: server side failure");
+          Setting.showMessage("error", `failed to save: ${res.msg}`);
-          this.updateWordsetField("name", this.state.wordsetName);
         }
       })
       .catch(error => {

web/src/WordsetGraph.js

@@ -71,13 +71,17 @@ class WordsetGraph extends React.Component {
     });
     WordsetBackend.getWordsetGraph("admin", this.state.wordsetName, this.state.clusterNumber, this.state.distanceLimit)
       .then((graph) => {
-        this.setState({
+        if (graph.status === "ok") {
-          graph: graph,
+          this.setState({
-          loading: false,
+            graph: graph.data,
-          selectedType: null,
+            loading: false,
-          selectedId: null,
+            selectedType: null,
-          selectedIds: [],
+            selectedId: null,
-        });
+            selectedIds: [],
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get wordset graph: ${graph.msg}`);
+        }
       });
   }
 

web/src/WordsetGraphPage.js

@@ -1,6 +1,7 @@
 import React from "react";
 import * as WordsetBackend from "./backend/WordsetBackend";
 import WordsetGraph from "./WordsetGraph";
+import * as Setting from "./Setting";
 
 class WordsetGraphPage extends React.Component {
   constructor(props) {
@@ -19,9 +20,13 @@ class WordsetGraphPage extends React.Component {
   getWordset() {
     WordsetBackend.getWordset(this.props.account.name, this.state.wordsetName)
       .then((wordset) => {
-        this.setState({
+        if (wordset.status === "ok") {
-          wordset: wordset,
+          this.setState({
-        });
+            wordset: wordset.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get wordset: ${wordset.msg}`);
+        }
       });
   }
 

web/src/WordsetListPage.js

@@ -22,9 +22,13 @@ class WordsetListPage extends React.Component {
   getWordsets() {
     WordsetBackend.getWordsets(this.props.account.name)
       .then((res) => {
-        this.setState({
+        if (res.status === "ok") {
-          wordsets: res,
+          this.setState({
-        });
+            wordsets: res.data,
+          });
+        } else {
+          Setting.showMessage("error", `Failed to get wordsets: ${res.msg}`);
+        }
       });
   }
 
@@ -44,10 +48,14 @@ class WordsetListPage extends React.Component {
     const newWordset = this.newWordset();
     WordsetBackend.addWordset(newWordset)
       .then((res) => {
-        Setting.showMessage("success", "Wordset added successfully");
+        if (res.status === "ok") {
-        this.setState({
+          Setting.showMessage("success", "Wordset added successfully");
-          wordsets: Setting.prependRow(this.state.wordsets, newWordset),
+          this.setState({
-        });
+            wordsets: Setting.prependRow(this.state.wordsets, newWordset),
+          });
+        } else {
+          Setting.showMessage("error", `Failed to add wordset: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `Wordset failed to add: ${error}`);
@@ -57,10 +65,14 @@ class WordsetListPage extends React.Component {
   deleteWordset(i) {
     WordsetBackend.deleteWordset(this.state.wordsets[i])
       .then((res) => {
-        Setting.showMessage("success", "Wordset deleted successfully");
+        if (res.status === "ok") {
-        this.setState({
+          Setting.showMessage("success", "Wordset deleted successfully");
-          wordsets: Setting.deleteRow(this.state.wordsets, i),
+          this.setState({
-        });
+            wordsets: Setting.deleteRow(this.state.wordsets, i),
+          });
+        } else {
+          Setting.showMessage("error", `Failed to delete wordset: ${res.msg}`);
+        }
       })
       .catch(error => {
         Setting.showMessage("error", `Wordset failed to delete: ${error}`);