You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
266 lines
6.8 KiB
266 lines
6.8 KiB
package service |
|
|
|
import ( |
|
"context" |
|
|
|
"go-common/app/admin/main/vip/model" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
|
|
"github.com/jinzhu/gorm" |
|
"github.com/pkg/errors" |
|
"golang.org/x/sync/errgroup" |
|
) |
|
|
|
// Privileges Privilege list. |
|
func (s *Service) Privileges(c context.Context, langType int8) (res []*model.PrivilegeResp, err error) { |
|
var ( |
|
ps []*model.Privilege |
|
prs []*model.PrivilegeResources |
|
) |
|
if ps, err = s.dao.PrivilegeList(c, langType); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
if prs, err = s.dao.PrivilegeResourcesList(c); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
prmap := make(map[int64]map[int8]*model.PrivilegeResources, len(prs)) |
|
for _, v := range prs { |
|
if prmap[v.PID] == nil { |
|
prmap[v.PID] = map[int8]*model.PrivilegeResources{} |
|
} |
|
prmap[v.PID][v.Type] = v |
|
} |
|
for i, v := range ps { |
|
r := &model.PrivilegeResp{ |
|
ID: v.ID, |
|
Name: v.Name, |
|
Title: v.Title, |
|
Explain: v.Explain, |
|
Type: v.Type, |
|
Operator: v.Operator, |
|
State: v.State, |
|
IconURL: v.IconURL, |
|
IconGrayURL: v.IconGrayURL, |
|
LangType: v.LangType, |
|
Order: int64(i), |
|
} |
|
if prmap[v.ID] != nil && prmap[v.ID][model.WebResources] != nil { |
|
r.WebLink = prmap[v.ID][model.WebResources].Link |
|
r.WebImageURL = prmap[v.ID][model.WebResources].ImageURL |
|
} |
|
if prmap[v.ID] != nil && prmap[v.ID][model.AppResources] != nil { |
|
r.AppLink = prmap[v.ID][model.AppResources].Link |
|
r.AppImageURL = prmap[v.ID][model.AppResources].ImageURL |
|
} |
|
res = append(res, r) |
|
} |
|
return |
|
} |
|
|
|
// UpdatePrivilegeState update privilege state. |
|
func (s *Service) UpdatePrivilegeState(c context.Context, p *model.Privilege) (err error) { |
|
if _, err = s.dao.UpdateStatePrivilege(c, p); err != nil { |
|
err = errors.WithStack(err) |
|
} |
|
return |
|
} |
|
|
|
// DeletePrivilege delete privilege . |
|
func (s *Service) DeletePrivilege(c context.Context, id int64) (err error) { |
|
if _, err = s.dao.DeletePrivilege(c, id); err != nil { |
|
err = errors.WithStack(err) |
|
} |
|
return |
|
} |
|
|
|
// AddPrivilege add privilege. |
|
func (s *Service) AddPrivilege(c context.Context, req *model.ArgAddPrivilege, img *model.ArgImage) (err error) { |
|
var ( |
|
iconURL string |
|
iconGrayURL string |
|
order int64 |
|
webImageURL string |
|
appImageURL string |
|
id int64 |
|
tx *gorm.DB |
|
) |
|
if iconURL, iconGrayURL, webImageURL, appImageURL, err = s.uploadImage(c, img); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
if iconURL == "" || iconGrayURL == "" { |
|
err = ecode.VipFileUploadFaildErr |
|
return |
|
} |
|
if order, err = s.dao.MaxOrder(c); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
order++ |
|
tx = s.dao.BeginGormTran(c) |
|
defer func() { |
|
if err != nil { |
|
if err1 := tx.Rollback(); err1 != nil { |
|
err = errors.Wrapf(err, "tx.Rollback(%+v)", req) |
|
} |
|
return |
|
} |
|
if err = tx.Commit().Error; err != nil { |
|
err = errors.Wrapf(err, "tx.Commit(%+v)", req) |
|
} |
|
}() |
|
if id, err = s.dao.AddPrivilege(tx, &model.Privilege{ |
|
Name: req.Name, |
|
Title: req.Title, |
|
Explain: req.Explain, |
|
Type: req.Type, |
|
Operator: req.Operator, |
|
State: model.NormalPrivilege, |
|
IconURL: iconURL, |
|
IconGrayURL: iconGrayURL, |
|
Order: order, |
|
LangType: req.LangType, |
|
}); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
if _, err = s.dao.AddPrivilegeResources(tx, &model.PrivilegeResources{ |
|
PID: id, |
|
Link: req.AppLink, |
|
ImageURL: appImageURL, |
|
Type: model.AppResources, |
|
}); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
if _, err = s.dao.AddPrivilegeResources(tx, &model.PrivilegeResources{ |
|
PID: id, |
|
Link: req.WebLink, |
|
ImageURL: webImageURL, |
|
Type: model.WebResources, |
|
}); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// UpdatePrivilege update privilege. |
|
func (s *Service) UpdatePrivilege(c context.Context, req *model.ArgUpdatePrivilege, img *model.ArgImage) (err error) { |
|
var ( |
|
iconURL string |
|
iconGrayURL string |
|
webImageURL string |
|
appImageURL string |
|
tx *gorm.DB |
|
) |
|
if iconURL, iconGrayURL, webImageURL, appImageURL, err = s.uploadImage(c, img); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
tx = s.dao.BeginGormTran(c) |
|
defer func() { |
|
if err != nil { |
|
if err1 := tx.Rollback().Error; err1 != nil { |
|
err = errors.Wrapf(err, "tx.Rollback(%+v)", req) |
|
} |
|
return |
|
} |
|
if err = tx.Commit().Error; err != nil { |
|
err = errors.Wrapf(err, "tx.Commit(%+v)", req) |
|
} |
|
}() |
|
if _, err = s.dao.UpdatePrivilege(tx, &model.Privilege{ |
|
ID: req.ID, |
|
Name: req.Name, |
|
Title: req.Title, |
|
Explain: req.Explain, |
|
Type: req.Type, |
|
Operator: req.Operator, |
|
State: model.NormalPrivilege, |
|
IconURL: iconURL, |
|
IconGrayURL: iconGrayURL, |
|
}); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
if _, err = s.dao.UpdatePrivilegeResources(tx, &model.PrivilegeResources{ |
|
PID: req.ID, |
|
Link: req.AppLink, |
|
ImageURL: appImageURL, |
|
Type: model.AppResources, |
|
}); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
if _, err = s.dao.UpdatePrivilegeResources(tx, &model.PrivilegeResources{ |
|
PID: req.ID, |
|
Link: req.WebLink, |
|
ImageURL: webImageURL, |
|
Type: model.WebResources, |
|
}); err != nil { |
|
err = errors.WithStack(err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
func (s *Service) uploadImage(c context.Context, req *model.ArgImage) (iconURL, iconGrayURL, webImageURL, appImageURL string, err error) { |
|
var g errgroup.Group |
|
if req.IconFileType == "" && |
|
req.IconGrayFileType == "" && |
|
req.WebImageFileType == "" && |
|
req.AppImageFileType == "" { |
|
return |
|
} |
|
if req.IconFileType != "" { |
|
g.Go(func() (err error) { |
|
//update icon. |
|
if iconURL, err = s.dao.Upload(c, "", req.IconFileType, req.IconBody, s.c.Bfs); err != nil { |
|
log.Error("d.Upload iconURL(%+v) error(%v)", req, err) |
|
} |
|
return |
|
}) |
|
} |
|
if req.IconGrayFileType != "" { |
|
g.Go(func() (err error) { |
|
//update gray icon. |
|
if iconGrayURL, err = s.dao.Upload(c, "", req.IconGrayFileType, req.IconGrayBody, s.c.Bfs); err != nil { |
|
log.Error("d.Upload iconGrayURL(%+v) error(%v)", req, err) |
|
} |
|
return |
|
}) |
|
} |
|
if req.WebImageFileType != "" { |
|
g.Go(func() (err error) { |
|
if webImageURL, err = s.dao.Upload(c, "", req.WebImageFileType, req.WebImageBody, s.c.Bfs); err != nil { |
|
log.Error("d.Upload webImageURL(%+v) error(%v)", req, err) |
|
} |
|
return |
|
}) |
|
} |
|
if req.AppImageFileType != "" { |
|
g.Go(func() (err error) { |
|
if appImageURL, err = s.dao.Upload(c, "", req.AppImageFileType, req.AppImageBody, s.c.Bfs); err != nil { |
|
log.Error("d.Upload appImageURL(%+v) error(%v)", req, err) |
|
} |
|
return |
|
}) |
|
} |
|
if err = g.Wait(); err != nil { |
|
log.Error("g.Wait error(%v)", err) |
|
return |
|
} |
|
return |
|
} |
|
|
|
// UpdateOrder update order. |
|
func (s *Service) UpdateOrder(c context.Context, a *model.ArgOrder) (err error) { |
|
if _, err = s.dao.UpdateOrder(c, a.AID, a.BID); err != nil { |
|
err = errors.WithStack(err) |
|
} |
|
return |
|
}
|
|
|