func (_ FilesResource) ApiCreate(res kit.Resource, obj kit.Model, r kit.Request) kit.Response {
// Verify that tmp path is set either in metadata or on model.
file := obj.(kit.File)
if file.GetTmpPath() == "" {
file.SetTmpPath(r.GetMeta().String("file"))
}
filePath := file.GetTmpPath()
if filePath == "" {
return kit.NewErrorResponse("no_tmp_path", "A tmp path must be set when creating a file", true)
}
tmpPath := getTmpPath(res)
if !strings.HasPrefix(filePath, tmpPath) && filePath[0] != '/' {
filePath = tmpPath + string(os.PathSeparator) + filePath
file.SetTmpPath(filePath)
}
// Build the file, save it to backend and persist it to the db.
err := res.Registry().FileService().BuildFile(file, r.GetUser(), true, true)
if err != nil {
kit.NewErrorResponse(err)
}
return &kit.AppResponse{
Data: file,
}
}
func (a *App) RunMethod(name string, r kit.Request, responder func(kit.Response), withFinishedChannel bool) (chan bool, apperror.Error) {
method := a.registry.Method(name)
if method == nil {
return nil, &apperror.Err{
Code: "unknown_method",
Message: fmt.Sprintf("The method %v does not exist", name),
}
}
if r.GetSession() == nil {
session, err := a.UserService().StartSession(r.GetUser(), "")
if err != nil {
return nil, err
}
r.SetSession(session)
}
instance := NewMethodInstance(method, r, responder)
if withFinishedChannel {
c := make(chan bool)
instance.finishedChannel = c
return c, a.sessionManager.QueueMethod(r.GetSession(), instance)
} else {
return nil, a.sessionManager.QueueMethod(r.GetSession(), instance)
}
}
func (res *Resource) ApiPartialUpdate(obj kit.Model, r kit.Request) kit.Response {
if updateHook, ok := res.hooks.(ApiUpdateHook); ok {
return updateHook.ApiUpdate(res, obj, r)
}
user := r.GetUser()
err := res.PartialUpdate(obj, user)
if err != nil {
return kit.NewErrorResponse(err)
}
return &kit.AppResponse{
Data: obj,
}
}
func (res *Resource) ApiDelete(id string, r kit.Request) kit.Response {
if deleteHook, ok := res.hooks.(ApiDeleteHook); ok {
return deleteHook.ApiDelete(res, id, r)
}
oldObj, err := res.FindOne(id)
if err != nil {
return kit.NewErrorResponse(err)
} else if oldObj == nil {
return kit.NewErrorResponse("not_found", "")
}
user := r.GetUser()
if err := res.Delete(oldObj, user); err != nil {
return kit.NewErrorResponse(err)
}
return &kit.AppResponse{
Data: oldObj,
}
}
func (res *Resource) ApiFindOne(rawId string, r kit.Request) kit.Response {
hook, ok := res.hooks.(ApiFindOneHook)
if ok {
return hook.ApiFindOne(res, rawId, r)
}
result, err := res.FindOne(rawId)
if err != nil {
return kit.NewErrorResponse(err)
} else if result == nil {
return kit.NewErrorResponse("not_found", "")
}
user := r.GetUser()
if allowFind, ok := res.hooks.(AllowFindHook); ok {
if !allowFind.AllowFind(res, result, user) {
return kit.NewErrorResponse("permission_denied", "")
}
}
return &kit.AppResponse{
Data: result,
}
}
func (res *Resource) ApiFind(query *db.Query, r kit.Request) kit.Response {
// If query is empty, query for all records.
if query == nil {
query = res.Q()
}
apiFindHook, ok := res.hooks.(ApiFindHook)
if ok {
return apiFindHook.ApiFind(res, query, r)
}
if alterQuery, ok := res.hooks.(ApiAlterQueryHook); ok {
alterQuery.ApiAlterQuery(res, query, r)
}
result, err := res.Query(query)
if err != nil {
return kit.NewErrorResponse(err)
}
user := r.GetUser()
if allowFind, ok := res.hooks.(AllowFindHook); ok {
finalItems := make([]kit.Model, 0)
for _, item := range result {
if allowFind.AllowFind(res, item, user) {
finalItems = append(finalItems, item)
}
}
result = finalItems
}
response := &kit.AppResponse{
Data: result,
}
// If a limit was set, count the total number of results
// and set count parameter in metadata.
limit := query.GetLimit()
if limit > 0 {
query.Limit(0).Offset(0)
count, err := res.backend.Count(query)
if err != nil {
return &kit.AppResponse{
Error: apperror.Wrap(err, "count_error", ""),
}
}
response.SetMeta(map[string]interface{}{
"count": count,
"total_pages": math.Ceil(float64(count) / float64(limit)),
})
}
if hook, ok := res.hooks.(ApiAfterFindHook); ok {
if err := hook.ApiAfterFind(res, result, r, response); err != nil {
return kit.NewErrorResponse(err)
}
}
return response
}