llvy.ltd/casdoor
1
0
Fork 0
mirror of https://github.com/casdoor/casdoor.git synced 2025-07-04 05:10:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat: return most backend API errors to frontend (#1836)

Browse Source 
* feat: return most backend API errros to frontend

Signed-off-by: yehong <239859435@qq.com>

* refactor: reduce int type change

Signed-off-by: yehong <239859435@qq.com>

* feat: return err backend in token.go

Signed-off-by: yehong <239859435@qq.com>

---------

Signed-off-by: yehong <239859435@qq.com>
This commit is contained in:
yehong
2023-05-30 15:49:39 +08:00
committed by GitHub
parent 34151c0095
commit 02e692a300
105 changed files with 3788 additions and 1734 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
object/adapter.go
View File

@ -119,7 +119,7 @@ func (a *Adapter) close() {
}
func (a *Adapter) createTable() {
showSql, _ := conf.GetConfigBool("showSql")
showSql := conf.GetConfigBool("showSql")
a.Engine.ShowSQL(showSql)
tableNamePrefix := conf.GetConfigString("tableNamePrefix")

241
object/application.go
View File

@ -79,134 +79,155 @@ type Application struct {
FormBackgroundUrl string `xorm:"varchar(200)" json:"formBackgroundUrl"`
}
func GetApplicationCount(owner, field, value string) int {
func GetApplicationCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Application{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Application{})
}
func GetOrganizationApplicationCount(owner, Organization, field, value string) int {
func GetOrganizationApplicationCount(owner, Organization, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Application{Organization: Organization})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Application{Organization: Organization})
}
func GetApplications(owner string) []*Application {
func GetApplications(owner string) ([]*Application, error) {
applications := []*Application{}
err := adapter.Engine.Desc("created_time").Find(&applications, &Application{Owner: owner})
if err != nil {
panic(err)
return applications, err
}
return applications
return applications, nil
}
func GetOrganizationApplications(owner string, organization string) []*Application {
func GetOrganizationApplications(owner string, organization string) ([]*Application, error) {
applications := []*Application{}
err := adapter.Engine.Desc("created_time").Find(&applications, &Application{Organization: organization})
if err != nil {
panic(err)
return applications, err
}
return applications
return applications, nil
}
func GetPaginationApplications(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Application {
func GetPaginationApplications(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Application, error) {
var applications []*Application
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&applications)
if err != nil {
panic(err)
return applications, err
}
return applications
return applications, nil
}
func GetPaginationOrganizationApplications(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) []*Application {
func GetPaginationOrganizationApplications(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) ([]*Application, error) {
applications := []*Application{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&applications, &Application{Organization: organization})
if err != nil {
panic(err)
return applications, err
}
return applications
return applications, nil
}
func getProviderMap(owner string) map[string]*Provider {
providers := GetProviders(owner)
m := map[string]*Provider{}
func getProviderMap(owner string) (m map[string]*Provider, err error) {
providers, err := GetProviders(owner)
if err != nil {
return nil, err
}
m = map[string]*Provider{}
for _, provider := range providers {
// Get QRCode only once
if provider.Type == "WeChat" && provider.DisableSsl && provider.Content == "" {
provider.Content, _ = idp.GetWechatOfficialAccountQRCode(provider.ClientId2, provider.ClientSecret2)
provider.Content, err = idp.GetWechatOfficialAccountQRCode(provider.ClientId2, provider.ClientSecret2)
if err != nil {
return
}
UpdateProvider(provider.Owner+"/"+provider.Name, provider)
}
m[provider.Name] = GetMaskedProvider(provider, true)
}
return m
return m, err
}
func extendApplicationWithProviders(application *Application) {
m := getProviderMap(application.Organization)
func extendApplicationWithProviders(application *Application) (err error) {
m, err := getProviderMap(application.Organization)
if err != nil {
return err
}
for _, providerItem := range application.Providers {
if provider, ok := m[providerItem.Name]; ok {
providerItem.Provider = provider
}
}
return
}
func extendApplicationWithOrg(application *Application) {
organization := getOrganization(application.Owner, application.Organization)
func extendApplicationWithOrg(application *Application) (err error) {
organization, err := getOrganization(application.Owner, application.Organization)
application.OrganizationObj = organization
return
}
func getApplication(owner string, name string) *Application {
func getApplication(owner string, name string) (*Application, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
application := Application{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&application)
if err != nil {
panic(err)
return nil, err
}
if existed {
extendApplicationWithProviders(&application)
extendApplicationWithOrg(&application)
return &application
err = extendApplicationWithProviders(&application)
if err != nil {
return nil, err
}
err = extendApplicationWithOrg(&application)
if err != nil {
return nil, err
}
return &application, nil
} else {
return nil
return nil, nil
}
}
func GetApplicationByOrganizationName(organization string) *Application {
func GetApplicationByOrganizationName(organization string) (*Application, error) {
application := Application{}
existed, err := adapter.Engine.Where("organization=?", organization).Get(&application)
if err != nil {
panic(err)
return nil, nil
}
if existed {
extendApplicationWithProviders(&application)
extendApplicationWithOrg(&application)
return &application
err = extendApplicationWithProviders(&application)
if err != nil {
return nil, err
}
err = extendApplicationWithOrg(&application)
if err != nil {
return nil, err
}
return &application, nil
} else {
return nil
return nil, nil
}
}
func GetApplicationByUser(user *User) *Application {
func GetApplicationByUser(user *User) (*Application, error) {
if user.SignupApplication != "" {
return getApplication("admin", user.SignupApplication)
} else {
@ -214,38 +235,46 @@ func GetApplicationByUser(user *User) *Application {
}
}
func GetApplicationByUserId(userId string) (*Application, *User) {
var application *Application
func GetApplicationByUserId(userId string) (application *Application, user *User, err error) {
owner, name := util.GetOwnerAndNameFromId(userId)
if owner == "app" {
application = getApplication("admin", name)
return application, nil
application, err = getApplication("admin", name)
return
}
user := GetUser(userId)
application = GetApplicationByUser(user)
return application, user
user, err = GetUser(userId)
if err != nil {
return nil, nil, err
}
application, err = GetApplicationByUser(user)
return
}
func GetApplicationByClientId(clientId string) *Application {
func GetApplicationByClientId(clientId string) (*Application, error) {
application := Application{}
existed, err := adapter.Engine.Where("client_id=?", clientId).Get(&application)
if err != nil {
panic(err)
return nil, err
}
if existed {
extendApplicationWithProviders(&application)
extendApplicationWithOrg(&application)
return &application
err = extendApplicationWithProviders(&application)
if err != nil {
return nil, err
}
err = extendApplicationWithOrg(&application)
if err != nil {
return nil, err
}
return &application, nil
} else {
return nil
return nil, nil
}
}
func GetApplication(id string) *Application {
func GetApplication(id string) (*Application, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getApplication(owner, name)
}
@ -288,11 +317,11 @@ func GetMaskedApplications(applications []*Application, userId string) []*Applic
return applications
}
func UpdateApplication(id string, application *Application) bool {
func UpdateApplication(id string, application *Application) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
oldApplication := getApplication(owner, name)
oldApplication, err := getApplication(owner, name)
if oldApplication == nil {
return false
return false, err
}
if name == "app-built-in" {
@ -300,14 +329,19 @@ func UpdateApplication(id string, application *Application) bool {
}
if name != application.Name {
err := applicationChangeTrigger(name, application.Name)
err = applicationChangeTrigger(name, application.Name)
if err != nil {
return false
return false, err
}
}
if oldApplication.ClientId != application.ClientId && GetApplicationByClientId(application.ClientId) != nil {
return false
applicationByClientId, err := GetApplicationByClientId(application.ClientId)
if err != nil {
return false, err
}
if oldApplication.ClientId != application.ClientId && applicationByClientId != nil {
return false, err
}
for _, providerItem := range application.Providers {
@ -320,13 +354,13 @@ func UpdateApplication(id string, application *Application) bool {
}
affected, err := session.Update(application)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddApplication(application *Application) bool {
func AddApplication(application *Application) (bool, error) {
if application.Owner == "" {
application.Owner = "admin"
}
@ -339,32 +373,39 @@ func AddApplication(application *Application) bool {
if application.ClientSecret == "" {
application.ClientSecret = util.GenerateClientSecret()
}
if GetApplicationByClientId(application.ClientId) != nil {
return false
app, err := GetApplicationByClientId(application.ClientId)
if err != nil {
return false, err
}
if app != nil {
return false, nil
}
for _, providerItem := range application.Providers {
providerItem.Provider = nil
}
affected, err := adapter.Engine.Insert(application)
if err != nil {
panic(err)
return false, nil
}
return affected != 0
return affected != 0, nil
}
func DeleteApplication(application *Application) bool {
func DeleteApplication(application *Application) (bool, error) {
if application.Name == "app-built-in" {
return false
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{application.Owner, application.Name}).Delete(&Application{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (application *Application) GetId() string {
@ -383,33 +424,43 @@ func (application *Application) IsRedirectUriValid(redirectUri string) bool {
return isValid
}
func IsOriginAllowed(origin string) bool {
applications := GetApplications("")
func IsOriginAllowed(origin string) (bool, error) {
applications, err := GetApplications("")
if err != nil {
return false, err
}
for _, application := range applications {
if application.IsRedirectUriValid(origin) {
return true
return true, nil
}
}
return false
return false, nil
}
func getApplicationMap(organization string) map[string]*Application {
applications := GetOrganizationApplications("admin", organization)
func getApplicationMap(organization string) (map[string]*Application, error) {
applicationMap := make(map[string]*Application)
applications, err := GetOrganizationApplications("admin", organization)
if err != nil {
return applicationMap, err
}
for _, application := range applications {
applicationMap[application.Name] = application
}
return applicationMap
return applicationMap, nil
}
func ExtendManagedAccountsWithUser(user *User) *User {
func ExtendManagedAccountsWithUser(user *User) (*User, error) {
if user.ManagedAccounts == nil || len(user.ManagedAccounts) == 0 {
return user
return user, nil
}
applicationMap := getApplicationMap(user.Owner)
applicationMap, err := getApplicationMap(user.Owner)
if err != nil {
return user, err
}
var managedAccounts []ManagedAccount
for _, managedAccount := range user.ManagedAccounts {
@ -421,7 +472,7 @@ func ExtendManagedAccountsWithUser(user *User) *User {
}
user.ManagedAccounts = managedAccounts
return user
return user, nil
}
func applicationChangeTrigger(oldName string, newName string) error {

18
object/application_item.go
View File

@ -14,8 +14,12 @@
package object
func (application *Application) GetProviderByCategory(category string) *Provider {
providers := GetProviders(application.Organization)
func (application *Application) GetProviderByCategory(category string) (*Provider, error) {
providers, err := GetProviders(application.Organization)
if err != nil {
return nil, err
}
m := map[string]*Provider{}
for _, provider := range providers {
if provider.Category != category {
@ -27,22 +31,22 @@ func (application *Application) GetProviderByCategory(category string) *Provider
for _, providerItem := range application.Providers {
if provider, ok := m[providerItem.Name]; ok {
return provider
return provider, nil
}
}
return nil
return nil, nil
}
func (application *Application) GetEmailProvider() *Provider {
func (application *Application) GetEmailProvider() (*Provider, error) {
return application.GetProviderByCategory("Email")
}
func (application *Application) GetSmsProvider() *Provider {
func (application *Application) GetSmsProvider() (*Provider, error) {
return application.GetProviderByCategory("SMS")
}
func (application *Application) GetStorageProvider() *Provider {
func (application *Application) GetStorageProvider() (*Provider, error) {
return application.GetProviderByCategory("Storage")
}

34
object/avatar.go
View File

@ -28,7 +28,11 @@ var defaultStorageProvider *Provider = nil
func InitDefaultStorageProvider() {
defaultStorageProviderStr := conf.GetConfigString("defaultStorageProvider")
if defaultStorageProviderStr != "" {
defaultStorageProvider = getProvider("admin", defaultStorageProviderStr)
var err error
defaultStorageProvider, err = getProvider("admin", defaultStorageProviderStr)
if err != nil {
panic(err)
}
}
}
@ -50,40 +54,44 @@ func downloadFile(url string) (*bytes.Buffer, error) {
return fileBuffer, nil
}
func getPermanentAvatarUrl(organization string, username string, url string, upload bool) string {
func getPermanentAvatarUrl(organization string, username string, url string, upload bool) (string, error) {
if url == "" {
return ""
return "", nil
}
if defaultStorageProvider == nil {
return ""
return "", nil
}
fullFilePath := fmt.Sprintf("/avatar/%s/%s.png", organization, username)
uploadedFileUrl, _ := GetUploadFileUrl(defaultStorageProvider, fullFilePath, false)
if upload {
DownloadAndUpload(url, fullFilePath, "en")
if err := DownloadAndUpload(url, fullFilePath, "en"); err != nil {
return "", err
}
}
return uploadedFileUrl
return uploadedFileUrl, nil
}
func DownloadAndUpload(url string, fullFilePath string, lang string) {
func DownloadAndUpload(url string, fullFilePath string, lang string) (err error) {
fileBuffer, err := downloadFile(url)
if err != nil {
panic(err)
return
}
_, _, err = UploadFileSafe(defaultStorageProvider, fullFilePath, fileBuffer, lang)
if err != nil {
panic(err)
return
}
return
}
func getPermanentAvatarUrlFromBuffer(organization string, username string, fileBuffer *bytes.Buffer, ext string, upload bool) string {
func getPermanentAvatarUrlFromBuffer(organization string, username string, fileBuffer *bytes.Buffer, ext string, upload bool) (string, error) {
if defaultStorageProvider == nil {
return ""
return "", nil
}
fullFilePath := fmt.Sprintf("/avatar/%s/%s%s", organization, username, ext)
@ -92,9 +100,9 @@ func getPermanentAvatarUrlFromBuffer(organization string, username string, fileB
if upload {
_, _, err := UploadFileSafe(defaultStorageProvider, fullFilePath, fileBuffer, "en")
if err != nil {
panic(err)
return "", err
}
}
return uploadedFileUrl
return uploadedFileUrl, nil
}

29
object/avatar_test.go
View File

@ -27,13 +27,21 @@ func TestSyncPermanentAvatars(t *testing.T) {
InitDefaultStorageProvider()
proxy.InitHttpClient()
users := GetGlobalUsers()
users, err := GetGlobalUsers()
if err != nil {
panic(err)
}
for i, user := range users {
if user.Avatar == "" {
continue
}
user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, true)
user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, true)
if err != nil {
panic(err)
}
updateUserColumn("permanent_avatar", user)
fmt.Printf("[%d/%d]: Update user: [%s]'s permanent avatar: %s\n", i, len(users), user.GetId(), user.PermanentAvatar)
}
@ -44,16 +52,27 @@ func TestUpdateAvatars(t *testing.T) {
InitDefaultStorageProvider()
proxy.InitHttpClient()
users := GetUsers("casdoor")
users, err := GetUsers("casdoor")
if err != nil {
panic(err)
}
for _, user := range users {
if strings.HasPrefix(user.Avatar, "http") {
continue
}
updated := user.refreshAvatar()
updated, err := user.refreshAvatar()
if err != nil {
panic(err)
}
if updated {
user.PermanentAvatar = "*"
UpdateUser(user.GetId(), user, []string{"avatar"}, true)
_, err = UpdateUser(user.GetId(), user, []string{"avatar"}, true)
if err != nil {
panic(err)
}
}
}
}

6
object/captcha.go
View File

@ -20,17 +20,17 @@ import (
"github.com/dchest/captcha"
)
func GetCaptcha() (string, []byte) {
func GetCaptcha() (string, []byte, error) {
id := captcha.NewLen(5)
var buffer bytes.Buffer
err := captcha.WriteImage(&buffer, id, 200, 80)
if err != nil {
panic(err)
return "", nil, err
}
return id, buffer.Bytes()
return id, buffer.Bytes(), nil
}
func VerifyCaptcha(id string, digits string) bool {

79
object/casbin_adapter.go
View File

@ -46,64 +46,59 @@ type CasbinAdapter struct {
Adapter *xormadapter.Adapter `xorm:"-" json:"-"`
}
func GetCasbinAdapterCount(owner, organization, field, value string) int {
func GetCasbinAdapterCount(owner, organization, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&CasbinAdapter{Organization: organization})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&CasbinAdapter{Organization: organization})
}
func GetCasbinAdapters(owner string, organization string) []*CasbinAdapter {
func GetCasbinAdapters(owner string, organization string) ([]*CasbinAdapter, error) {
adapters := []*CasbinAdapter{}
err := adapter.Engine.Where("owner = ? and organization = ?", owner, organization).Find(&adapters)
if err != nil {
panic(err)
return adapters, err
}
return adapters
return adapters, nil
}
func GetPaginationCasbinAdapters(owner, organization string, page, limit int, field, value, sort, order string) []*CasbinAdapter {
func GetPaginationCasbinAdapters(owner, organization string, page, limit int, field, value, sort, order string) ([]*CasbinAdapter, error) {
session := GetSession(owner, page, limit, field, value, sort, order)
adapters := []*CasbinAdapter{}
err := session.Find(&adapters, &CasbinAdapter{Organization: organization})
if err != nil {
panic(err)
return adapters, err
}
return adapters
return adapters, nil
}
func getCasbinAdapter(owner, name string) *CasbinAdapter {
func getCasbinAdapter(owner, name string) (*CasbinAdapter, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
casbinAdapter := CasbinAdapter{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&casbinAdapter)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &casbinAdapter
return &casbinAdapter, nil
} else {
return nil
return nil, nil
}
}
func GetCasbinAdapter(id string) *CasbinAdapter {
func GetCasbinAdapter(id string) (*CasbinAdapter, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getCasbinAdapter(owner, name)
}
func UpdateCasbinAdapter(id string, casbinAdapter *CasbinAdapter) bool {
func UpdateCasbinAdapter(id string, casbinAdapter *CasbinAdapter) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getCasbinAdapter(owner, name) == nil {
return false
if casbinAdapter, err := getCasbinAdapter(owner, name); casbinAdapter == nil {
return false, err
}
session := adapter.Engine.ID(core.PK{owner, name}).AllCols()
@ -112,28 +107,28 @@ func UpdateCasbinAdapter(id string, casbinAdapter *CasbinAdapter) bool {
}
affected, err := session.Update(casbinAdapter)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddCasbinAdapter(casbinAdapter *CasbinAdapter) bool {
func AddCasbinAdapter(casbinAdapter *CasbinAdapter) (bool, error) {
affected, err := adapter.Engine.Insert(casbinAdapter)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteCasbinAdapter(casbinAdapter *CasbinAdapter) bool {
func DeleteCasbinAdapter(casbinAdapter *CasbinAdapter) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{casbinAdapter.Owner, casbinAdapter.Name}).Delete(&CasbinAdapter{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (casbinAdapter *CasbinAdapter) GetId() string {
@ -214,7 +209,11 @@ func matrixToCasbinRules(Ptype string, policies [][]string) []*xormadapter.Casbi
}
func SyncPolicies(casbinAdapter *CasbinAdapter) ([]*xormadapter.CasbinRule, error) {
modelObj := getModel(casbinAdapter.Owner, casbinAdapter.Model)
modelObj, err := getModel(casbinAdapter.Owner, casbinAdapter.Model)
if err != nil {
return nil, err
}
enforcer, err := initEnforcer(modelObj, casbinAdapter)
if err != nil {
return nil, err
@ -229,7 +228,11 @@ func SyncPolicies(casbinAdapter *CasbinAdapter) ([]*xormadapter.CasbinRule, erro
}
func UpdatePolicy(oldPolicy, newPolicy []string, casbinAdapter *CasbinAdapter) (bool, error) {
modelObj := getModel(casbinAdapter.Owner, casbinAdapter.Model)
modelObj, err := getModel(casbinAdapter.Owner, casbinAdapter.Model)
if err != nil {
return false, err
}
enforcer, err := initEnforcer(modelObj, casbinAdapter)
if err != nil {
return false, err
@ -243,7 +246,11 @@ func UpdatePolicy(oldPolicy, newPolicy []string, casbinAdapter *CasbinAdapter) (
}
func AddPolicy(policy []string, casbinAdapter *CasbinAdapter) (bool, error) {
modelObj := getModel(casbinAdapter.Owner, casbinAdapter.Model)
modelObj, err := getModel(casbinAdapter.Owner, casbinAdapter.Model)
if err != nil {
return false, err
}
enforcer, err := initEnforcer(modelObj, casbinAdapter)
if err != nil {
return false, err
@ -257,7 +264,11 @@ func AddPolicy(policy []string, casbinAdapter *CasbinAdapter) (bool, error) {
}
func RemovePolicy(policy []string, casbinAdapter *CasbinAdapter) (bool, error) {
modelObj := getModel(casbinAdapter.Owner, casbinAdapter.Model)
modelObj, err := getModel(casbinAdapter.Owner, casbinAdapter.Model)
if err != nil {
return false, err
}
enforcer, err := initEnforcer(modelObj, casbinAdapter)
if err != nil {
return false, err

102
object/cert.go
View File

@ -47,137 +47,133 @@ func GetMaskedCert(cert *Cert) *Cert {
return cert
}
func GetMaskedCerts(certs []*Cert) []*Cert {
func GetMaskedCerts(certs []*Cert, err error) ([]*Cert, error) {
if err != nil {
return nil, err
}
for _, cert := range certs {
cert = GetMaskedCert(cert)
}
return certs
return certs, nil
}
func GetCertCount(owner, field, value string) int {
func GetCertCount(owner, field, value string) (int64, error) {
session := GetSession("", -1, -1, field, value, "", "")
count, err := session.Where("owner = ? or owner = ? ", "admin", owner).Count(&Cert{})
if err != nil {
panic(err)
}
return int(count)
return session.Where("owner = ? or owner = ? ", "admin", owner).Count(&Cert{})
}
func GetCerts(owner string) []*Cert {
func GetCerts(owner string) ([]*Cert, error) {
certs := []*Cert{}
err := adapter.Engine.Where("owner = ? or owner = ? ", "admin", owner).Desc("created_time").Find(&certs, &Cert{})
if err != nil {
panic(err)
return certs, err
}
return certs
return certs, nil
}
func GetPaginationCerts(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Cert {
func GetPaginationCerts(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Cert, error) {
certs := []*Cert{}
session := GetSession("", offset, limit, field, value, sortField, sortOrder)
err := session.Where("owner = ? or owner = ? ", "admin", owner).Find(&certs)
if err != nil {
panic(err)
return certs, err
}
return certs
return certs, nil
}
func GetGlobalCertsCount(field, value string) int {
func GetGlobalCertsCount(field, value string) (int64, error) {
session := GetSession("", -1, -1, field, value, "", "")
count, err := session.Count(&Cert{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Cert{})
}
func GetGlobleCerts() []*Cert {
func GetGlobleCerts() ([]*Cert, error) {
certs := []*Cert{}
err := adapter.Engine.Desc("created_time").Find(&certs)
if err != nil {
panic(err)
return certs, err
}
return certs
return certs, nil
}
func GetPaginationGlobalCerts(offset, limit int, field, value, sortField, sortOrder string) []*Cert {
func GetPaginationGlobalCerts(offset, limit int, field, value, sortField, sortOrder string) ([]*Cert, error) {
certs := []*Cert{}
session := GetSession("", offset, limit, field, value, sortField, sortOrder)
err := session.Find(&certs)
if err != nil {
panic(err)
return certs, err
}
return certs
return certs, nil
}
func getCert(owner string, name string) *Cert {
func getCert(owner string, name string) (*Cert, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
cert := Cert{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&cert)
if err != nil {
panic(err)
return &cert, err
}
if existed {
return &cert
return &cert, nil
} else {
return nil
return nil, nil
}
}
func getCertByName(name string) *Cert {
func getCertByName(name string) (*Cert, error) {
if name == "" {
return nil
return nil, nil
}
cert := Cert{Name: name}
existed, err := adapter.Engine.Get(&cert)
if err != nil {
panic(err)
return &cert, nil
}
if existed {
return &cert
return &cert, nil
} else {
return nil
return nil, nil
}
}
func GetCert(id string) *Cert {
func GetCert(id string) (*Cert, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getCert(owner, name)
}
func UpdateCert(id string, cert *Cert) bool {
func UpdateCert(id string, cert *Cert) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getCert(owner, name) == nil {
return false
if c, err := getCert(owner, name); err != nil {
return false, err
} else if c == nil {
return false, nil
}
if name != cert.Name {
err := certChangeTrigger(name, cert.Name)
if err != nil {
return false
return false, nil
}
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(cert)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddCert(cert *Cert) bool {
func AddCert(cert *Cert) (bool, error) {
if cert.Certificate == "" || cert.PrivateKey == "" {
certificate, privateKey := generateRsaKeys(cert.BitSize, cert.ExpireInYears, cert.Name, cert.Owner)
cert.Certificate = certificate
@ -186,26 +182,26 @@ func AddCert(cert *Cert) bool {
affected, err := adapter.Engine.Insert(cert)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteCert(cert *Cert) bool {
func DeleteCert(cert *Cert) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{cert.Owner, cert.Name}).Delete(&Cert{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (p *Cert) GetId() string {
return fmt.Sprintf("%s/%s", p.Owner, p.Name)
}
func getCertByApplication(application *Application) *Cert {
func getCertByApplication(application *Application) (*Cert, error) {
if application.Cert != "" {
return getCertByName(application.Cert)
} else {
@ -213,7 +209,7 @@ func getCertByApplication(application *Application) *Cert {
}
}
func GetDefaultCert() *Cert {
func GetDefaultCert() (*Cert, error) {
return getCert("admin", "cert-built-in")
}

86
object/chat.go
View File

@ -37,92 +37,104 @@ type Chat struct {
MessageCount int `json:"messageCount"`
}
func GetMaskedChat(chat *Chat) *Chat {
func GetMaskedChat(chat *Chat, err ...error) (*Chat, error) {
if len(err) > 0 && err[0] != nil {
return nil, err[0]
}
if chat == nil {
return nil
return nil, nil
}
return chat
return chat, nil
}
func GetMaskedChats(chats []*Chat) []*Chat {
func GetMaskedChats(chats []*Chat, errs ...error) ([]*Chat, error) {
if len(errs) > 0 && errs[0] != nil {
return nil, errs[0]
}
var err error
for _, chat := range chats {
chat = GetMaskedChat(chat)
chat, err = GetMaskedChat(chat)
if err != nil {
return nil, err
}
}
return chats
return chats, nil
}
func GetChatCount(owner, field, value string) int {
func GetChatCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Chat{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Chat{})
}
func GetChats(owner string) []*Chat {
func GetChats(owner string) ([]*Chat, error) {
chats := []*Chat{}
err := adapter.Engine.Desc("created_time").Find(&chats, &Chat{Owner: owner})
if err != nil {
panic(err)
return chats, err
}
return chats
return chats, nil
}
func GetPaginationChats(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Chat {
func GetPaginationChats(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Chat, error) {
chats := []*Chat{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&chats)
if err != nil {
panic(err)
return chats, err
}
return chats
return chats, nil
}
func getChat(owner string, name string) *Chat {
func getChat(owner string, name string) (*Chat, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
chat := Chat{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&chat)
if err != nil {
panic(err)
return &chat, err
}
if existed {
return &chat
return &chat, nil
} else {
return nil
return nil, nil
}
}
func GetChat(id string) *Chat {
func GetChat(id string) (*Chat, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getChat(owner, name)
}
func UpdateChat(id string, chat *Chat) bool {
func UpdateChat(id string, chat *Chat) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getChat(owner, name) == nil {
return false
if c, err := getChat(owner, name); err != nil {
return false, err
} else if c == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(chat)
if err != nil {
panic(err)
return false, nil
}
return affected != 0
return affected != 0, nil
}
func AddChat(chat *Chat) bool {
func AddChat(chat *Chat) (bool, error) {
if chat.Type == "AI" && chat.User2 == "" {
provider := getDefaultAiProvider()
provider, err := getDefaultAiProvider()
if err != nil {
return false, err
}
if provider != nil {
chat.User2 = provider.Name
}
@ -130,23 +142,23 @@ func AddChat(chat *Chat) bool {
affected, err := adapter.Engine.Insert(chat)
if err != nil {
panic(err)
return false, nil
}
return affected != 0
return affected != 0, nil
}
func DeleteChat(chat *Chat) bool {
func DeleteChat(chat *Chat) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{chat.Owner, chat.Name}).Delete(&Chat{})
if err != nil {
panic(err)
return false, err
}
if affected != 0 {
return DeleteChatMessages(chat.Name)
}
return affected != 0
return affected != 0, nil
}
func (p *Chat) GetId() string {

53
object/check.go
View File

@ -170,7 +170,11 @@ func CheckPassword(user *User, password string, lang string, options ...bool) st
}
}
organization := GetOrganizationByUser(user)
organization, err := GetOrganizationByUser(user)
if err != nil {
panic(err)
}
if organization == nil {
return i18n.Translate(lang, "check:Organization does not exist")
}
@ -200,7 +204,11 @@ func CheckPassword(user *User, password string, lang string, options ...bool) st
}
func checkLdapUserPassword(user *User, password string, lang string) string {
ldaps := GetLdaps(user.Owner)
ldaps, err := GetLdaps(user.Owner)
if err != nil {
return err.Error()
}
ldapLoginSuccess := false
hit := false
@ -247,7 +255,11 @@ func CheckUserPassword(organization string, username string, password string, la
if len(options) > 0 {
enableCaptcha = options[0]
}
user := GetUserByFields(organization, username)
user, err := GetUserByFields(organization, username)
if err != nil {
panic(err)
}
if user == nil || user.IsDeleted {
return nil, fmt.Sprintf(i18n.Translate(lang, "general:The user: %s doesn't exist"), util.GetId(organization, username))
}
@ -284,7 +296,11 @@ func CheckUserPermission(requestUserId, userId string, strict bool, lang string)
userOwner := util.GetOwnerFromId(userId)
if userId != "" {
targetUser := GetUser(userId)
targetUser, err := GetUser(userId)
if err != nil {
panic(err)
}
if targetUser == nil {
if strings.HasPrefix(requestUserId, "built-in/") {
return true, nil
@ -300,7 +316,11 @@ func CheckUserPermission(requestUserId, userId string, strict bool, lang string)
if strings.HasPrefix(requestUserId, "app/") {
hasPermission = true
} else {
requestUser := GetUser(requestUserId)
requestUser, err := GetUser(requestUserId)
if err != nil {
return false, err
}
if requestUser == nil {
return false, fmt.Errorf(i18n.Translate(lang, "check:Session outdated, please login again"))
}
@ -321,13 +341,17 @@ func CheckUserPermission(requestUserId, userId string, strict bool, lang string)
}
func CheckAccessPermission(userId string, application *Application) (bool, error) {
var err error
if userId == "built-in/admin" {
return true, nil
}
permissions := GetPermissions(application.Organization)
permissions, err := GetPermissions(application.Organization)
if err != nil {
return false, err
}
allowed := true
var err error
for _, permission := range permissions {
if !permission.IsEnabled || len(permission.Users) == 0 {
continue
@ -403,9 +427,9 @@ func CheckUpdateUser(oldUser, user *User, lang string) string {
return ""
}
func CheckToEnableCaptcha(application *Application, organization, username string) bool {
func CheckToEnableCaptcha(application *Application, organization, username string) (bool, error) {
if len(application.Providers) == 0 {
return false
return false, nil
}
for _, providerItem := range application.Providers {
@ -414,12 +438,15 @@ func CheckToEnableCaptcha(application *Application, organization, username strin
}
if providerItem.Provider.Category == "Captcha" {
if providerItem.Rule == "Dynamic" {
user := GetUserByFields(organization, username)
return user != nil && user.SigninWrongTimes >= SigninWrongTimesLimit
user, err := GetUserByFields(organization, username)
if err != nil {
return false, err
}
return user != nil && user.SigninWrongTimes >= SigninWrongTimesLimit, nil
}
return providerItem.Rule == "Always"
return providerItem.Rule == "Always", nil
}
}
return false
return false, nil
}

87
object/init.go
View File

@ -74,7 +74,11 @@ func getBuiltInAccountItems() []*AccountItem {
}
func initBuiltInOrganization() bool {
organization := getOrganization("admin", "built-in")
organization, err := getOrganization("admin", "built-in")
if err != nil {
panic(err)
}
if organization != nil {
return true
}
@ -96,12 +100,19 @@ func initBuiltInOrganization() bool {
EnableSoftDeletion: false,
IsProfilePublic: false,
}
AddOrganization(organization)
_, err = AddOrganization(organization)
if err != nil {
panic(err)
}
return false
}
func initBuiltInUser() {
user := getUser("built-in", "admin")
user, err := getUser("built-in", "admin")
if err != nil {
panic(err)
}
if user != nil {
return
}
@ -131,11 +142,18 @@ func initBuiltInUser() {
CreatedIp: "127.0.0.1",
Properties: make(map[string]string),
}
AddUser(user)
_, err = AddUser(user)
if err != nil {
panic(err)
}
}
func initBuiltInApplication() {
application := getApplication("admin", "app-built-in")
application, err := getApplication("admin", "app-built-in")
if err != nil {
panic(err)
}
if application != nil {
return
}
@ -168,7 +186,10 @@ func initBuiltInApplication() {
ExpireInHours: 168,
FormOffset: 2,
}
AddApplication(application)
_, err = AddApplication(application)
if err != nil {
panic(err)
}
}
func readTokenFromFile() (string, string) {
@ -187,7 +208,11 @@ func readTokenFromFile() (string, string) {
func initBuiltInCert() {
tokenJwtCertificate, tokenJwtPrivateKey := readTokenFromFile()
cert := getCert("admin", "cert-built-in")
cert, err := getCert("admin", "cert-built-in")
if err != nil {
panic(err)
}
if cert != nil {
return
}
@ -205,11 +230,18 @@ func initBuiltInCert() {
Certificate: tokenJwtCertificate,
PrivateKey: tokenJwtPrivateKey,
}
AddCert(cert)
_, err = AddCert(cert)
if err != nil {
panic(err)
}
}
func initBuiltInLdap() {
ldap := GetLdap("ldap-built-in")
ldap, err := GetLdap("ldap-built-in")
if err != nil {
panic(err)
}
if ldap != nil {
return
}
@ -226,11 +258,18 @@ func initBuiltInLdap() {
AutoSync: 0,
LastSync: "",
}
AddLdap(ldap)
_, err = AddLdap(ldap)
if err != nil {
panic(err)
}
}
func initBuiltInProvider() {
provider := GetProvider(util.GetId("admin", "provider_captcha_default"))
provider, err := GetProvider(util.GetId("admin", "provider_captcha_default"))
if err != nil {
panic(err)
}
if provider != nil {
return
}
@ -243,7 +282,10 @@ func initBuiltInProvider() {
Category: "Captcha",
Type: "Default",
}
AddProvider(provider)
_, err = AddProvider(provider)
if err != nil {
panic(err)
}
}
func initWebAuthn() {
@ -251,7 +293,11 @@ func initWebAuthn() {
}
func initBuiltInModel() {
model := GetModel("built-in/model-built-in")
model, err := GetModel("built-in/model-built-in")
if err != nil {
panic(err)
}
if model != nil {
return
}
@ -274,11 +320,17 @@ e = some(where (p.eft == allow))
[matchers]
m = r.sub == p.sub && r.obj == p.obj && r.act == p.act`,
}
AddModel(model)
_, err = AddModel(model)
if err != nil {
panic(err)
}
}
func initBuiltInPermission() {
permission := GetPermission("built-in/permission-built-in")
permission, err := GetPermission("built-in/permission-built-in")
if err != nil {
panic(err)
}
if permission != nil {
return
}
@ -298,5 +350,8 @@ func initBuiltInPermission() {
Effect: "Allow",
IsEnabled: true,
}
AddPermission(permission)
_, err = AddPermission(permission)
if err != nil {
panic(err)
}
}

178
object/init_data.go
View File

@ -35,7 +35,11 @@ type InitData struct {
}
func InitFromFile() {
initData := readInitDataFromFile("./init_data.json")
initData, err := readInitDataFromFile("./init_data.json")
if err != nil {
panic(err)
}
if initData != nil {
for _, organization := range initData.Organizations {
initDefinedOrganization(organization)
@ -85,9 +89,9 @@ func InitFromFile() {
}
}
func readInitDataFromFile(filePath string) *InitData {
func readInitDataFromFile(filePath string) (*InitData, error) {
if !util.FileExist(filePath) {
return nil
return nil, nil
}
s := util.ReadStringFromPath(filePath)
@ -111,7 +115,7 @@ func readInitDataFromFile(filePath string) *InitData {
}
err := util.JsonToStruct(s, data)
if err != nil {
panic(err)
return nil, err
}
// transform nil slice to empty slice
@ -170,142 +174,246 @@ func readInitDataFromFile(filePath string) *InitData {
}
}
return data
return data, nil
}
func initDefinedOrganization(organization *Organization) {
existed := getOrganization(organization.Owner, organization.Name)
existed, err := getOrganization(organization.Owner, organization.Name)
if err != nil {
panic(err)
}
if existed != nil {
return
}
organization.CreatedTime = util.GetCurrentTime()
organization.AccountItems = getBuiltInAccountItems()
AddOrganization(organization)
_, err = AddOrganization(organization)
if err != nil {
panic(err)
}
}
func initDefinedApplication(application *Application) {
existed := getApplication(application.Owner, application.Name)
existed, err := getApplication(application.Owner, application.Name)
if err != nil {
panic(err)
}
if existed != nil {
return
}
application.CreatedTime = util.GetCurrentTime()
AddApplication(application)
_, err = AddApplication(application)
if err != nil {
panic(err)
}
}
func initDefinedUser(user *User) {
existed := getUser(user.Owner, user.Name)
existed, err := getUser(user.Owner, user.Name)
if err != nil {
panic(err)
}
if existed != nil {
return
}
user.CreatedTime = util.GetCurrentTime()
user.Id = util.GenerateId()
user.Properties = make(map[string]string)
AddUser(user)
_, err = AddUser(user)
if err != nil {
panic(err)
}
}
func initDefinedCert(cert *Cert) {
existed := getCert(cert.Owner, cert.Name)
existed, err := getCert(cert.Owner, cert.Name)
if err != nil {
panic(err)
}
if existed != nil {
return
}
cert.CreatedTime = util.GetCurrentTime()
AddCert(cert)
_, err = AddCert(cert)
if err != nil {
panic(err)
}
}
func initDefinedLdap(ldap *Ldap) {
existed := GetLdap(ldap.Id)
existed, err := GetLdap(ldap.Id)
if err != nil {
panic(err)
}
if existed != nil {
return
}
AddLdap(ldap)
_, err = AddLdap(ldap)
if err != nil {
panic(err)
}
}
func initDefinedProvider(provider *Provider) {
existed := GetProvider(util.GetId("admin", provider.Name))
existed, err := GetProvider(util.GetId("admin", provider.Name))
if err != nil {
panic(err)
}
if existed != nil {
return
}
AddProvider(provider)
_, err = AddProvider(provider)
if err != nil {
panic(err)
}
}
func initDefinedModel(model *Model) {
existed := GetModel(model.GetId())
existed, err := GetModel(model.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
model.CreatedTime = util.GetCurrentTime()
AddModel(model)
_, err = AddModel(model)
if err != nil {
panic(err)
}
}
func initDefinedPermission(permission *Permission) {
existed := GetPermission(permission.GetId())
existed, err := GetPermission(permission.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
permission.CreatedTime = util.GetCurrentTime()
AddPermission(permission)
_, err = AddPermission(permission)
if err != nil {
panic(err)
}
}
func initDefinedPayment(payment *Payment) {
existed := GetPayment(payment.GetId())
existed, err := GetPayment(payment.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
payment.CreatedTime = util.GetCurrentTime()
AddPayment(payment)
_, err = AddPayment(payment)
if err != nil {
panic(err)
}
}
func initDefinedProduct(product *Product) {
existed := GetProduct(product.GetId())
existed, err := GetProduct(product.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
product.CreatedTime = util.GetCurrentTime()
AddProduct(product)
_, err = AddProduct(product)
if err != nil {
panic(err)
}
}
func initDefinedResource(resource *Resource) {
existed := GetResource(resource.GetId())
existed, err := GetResource(resource.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
resource.CreatedTime = util.GetCurrentTime()
AddResource(resource)
_, err = AddResource(resource)
if err != nil {
panic(err)
}
}
func initDefinedRole(role *Role) {
existed := GetRole(role.GetId())
existed, err := GetRole(role.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
role.CreatedTime = util.GetCurrentTime()
AddRole(role)
_, err = AddRole(role)
if err != nil {
panic(err)
}
}
func initDefinedSyncer(syncer *Syncer) {
existed := GetSyncer(syncer.GetId())
existed, err := GetSyncer(syncer.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
syncer.CreatedTime = util.GetCurrentTime()
AddSyncer(syncer)
_, err = AddSyncer(syncer)
if err != nil {
panic(err)
}
}
func initDefinedToken(token *Token) {
existed := GetToken(token.GetId())
existed, err := GetToken(token.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
token.CreatedTime = util.GetCurrentTime()
AddToken(token)
_, err = AddToken(token)
if err != nil {
panic(err)
}
}
func initDefinedWebhook(webhook *Webhook) {
existed := GetWebhook(webhook.GetId())
existed, err := GetWebhook(webhook.GetId())
if err != nil {
panic(err)
}
if existed != nil {
return
}
webhook.CreatedTime = util.GetCurrentTime()
AddWebhook(webhook)
_, err = AddWebhook(webhook)
if err != nil {
panic(err)
}
}

48
object/ldap.go
View File

@ -37,7 +37,7 @@ type Ldap struct {
LastSync string `xorm:"varchar(100)" json:"lastSync"`
}
func AddLdap(ldap *Ldap) bool {
func AddLdap(ldap *Ldap) (bool, error) {
if len(ldap.Id) == 0 {
ldap.Id = util.GenerateId()
}
@ -48,13 +48,13 @@ func AddLdap(ldap *Ldap) bool {
affected, err := adapter.Engine.Insert(ldap)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func CheckLdapExist(ldap *Ldap) bool {
func CheckLdapExist(ldap *Ldap) (bool, error) {
var result []*Ldap
err := adapter.Engine.Find(&result, &Ldap{
Owner: ldap.Owner,
@ -65,63 +65,65 @@ func CheckLdapExist(ldap *Ldap) bool {
BaseDn: ldap.BaseDn,
})
if err != nil {
panic(err)
return false, err
}
if len(result) > 0 {
return true
return true, nil
}
return false
return false, nil
}
func GetLdaps(owner string) []*Ldap {
func GetLdaps(owner string) ([]*Ldap, error) {
var ldaps []*Ldap
err := adapter.Engine.Desc("created_time").Find(&ldaps, &Ldap{Owner: owner})
if err != nil {
panic(err)
return ldaps, err
}
return ldaps
return ldaps, nil
}
func GetLdap(id string) *Ldap {
func GetLdap(id string) (*Ldap, error) {
if util.IsStringsEmpty(id) {
return nil
return nil, nil
}
ldap := Ldap{Id: id}
existed, err := adapter.Engine.Get(&ldap)
if err != nil {
panic(err)
return &ldap, nil
}
if existed {
return &ldap
return &ldap, nil
} else {
return nil
return nil, nil
}
}
func UpdateLdap(ldap *Ldap) bool {
if GetLdap(ldap.Id) == nil {
return false
func UpdateLdap(ldap *Ldap) (bool, error) {
if l, err := GetLdap(ldap.Id); err != nil {
return false, nil
} else if l == nil {
return false, nil
}
affected, err := adapter.Engine.ID(ldap.Id).Cols("owner", "server_name", "host",
"port", "enable_ssl", "username", "password", "base_dn", "filter", "filter_fields", "auto_sync").Update(ldap)
if err != nil {
panic(err)
return false, nil
}
return affected != 0
return affected != 0, nil
}
func DeleteLdap(ldap *Ldap) bool {
func DeleteLdap(ldap *Ldap) (bool, error) {
affected, err := adapter.Engine.ID(ldap.Id).Delete(&Ldap{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}

49
object/ldap_autosync.go
View File

@ -18,7 +18,10 @@ var globalLdapAutoSynchronizer *LdapAutoSynchronizer
func InitLdapAutoSynchronizer() {
globalLdapAutoSynchronizer = NewLdapAutoSynchronizer()
globalLdapAutoSynchronizer.LdapAutoSynchronizerStartUpAll()
err := globalLdapAutoSynchronizer.LdapAutoSynchronizerStartUpAll()
if err != nil {
panic(err)
}
}
func NewLdapAutoSynchronizer() *LdapAutoSynchronizer {
@ -37,7 +40,11 @@ func (l *LdapAutoSynchronizer) StartAutoSync(ldapId string) error {
l.Lock()
defer l.Unlock()
ldap := GetLdap(ldapId)
ldap, err := GetLdap(ldapId)
if err != nil {
return err
}
if ldap == nil {
return fmt.Errorf("ldap %s doesn't exist", ldapId)
}
@ -49,7 +56,12 @@ func (l *LdapAutoSynchronizer) StartAutoSync(ldapId string) error {
stopChan := make(chan struct{})
l.ldapIdToStopChan[ldapId] = stopChan
logs.Info(fmt.Sprintf("autoSync started for %s", ldap.Id))
util.SafeGoroutine(func() { l.syncRoutine(ldap, stopChan) })
util.SafeGoroutine(func() {
err := l.syncRoutine(ldap, stopChan)
if err != nil {
panic(err)
}
})
return nil
}
@ -63,18 +75,22 @@ func (l *LdapAutoSynchronizer) StopAutoSync(ldapId string) {
}
// autosync goroutine
func (l *LdapAutoSynchronizer) syncRoutine(ldap *Ldap, stopChan chan struct{}) {
func (l *LdapAutoSynchronizer) syncRoutine(ldap *Ldap, stopChan chan struct{}) error {
ticker := time.NewTicker(time.Duration(ldap.AutoSync) * time.Minute)
defer ticker.Stop()
for {
select {
case <-stopChan:
logs.Info(fmt.Sprintf("autoSync goroutine for %s stopped", ldap.Id))
return
return nil
case <-ticker.C:
}
UpdateLdapSyncTime(ldap.Id)
err := UpdateLdapSyncTime(ldap.Id)
if err != nil {
return err
}
// fetch all users
conn, err := ldap.GetLdapConn()
if err != nil {
@ -100,24 +116,35 @@ func (l *LdapAutoSynchronizer) syncRoutine(ldap *Ldap, stopChan chan struct{}) {
// LdapAutoSynchronizerStartUpAll
// start all autosync goroutine for existing ldap servers in each organizations
func (l *LdapAutoSynchronizer) LdapAutoSynchronizerStartUpAll() {
func (l *LdapAutoSynchronizer) LdapAutoSynchronizerStartUpAll() error {
organizations := []*Organization{}
err := adapter.Engine.Desc("created_time").Find(&organizations)
if err != nil {
logs.Info("failed to Star up LdapAutoSynchronizer; ")
}
for _, org := range organizations {
for _, ldap := range GetLdaps(org.Name) {
ldaps, err := GetLdaps(org.Name)
if err != nil {
return err
}
for _, ldap := range ldaps {
if ldap.AutoSync != 0 {
l.StartAutoSync(ldap.Id)
err = l.StartAutoSync(ldap.Id)
if err != nil {
return err
}
}
}
}
return nil
}
func UpdateLdapSyncTime(ldapId string) {
func UpdateLdapSyncTime(ldapId string) error {
_, err := adapter.Engine.ID(ldapId).Update(&Ldap{LastSync: util.GetCurrentTime()})
if err != nil {
panic(err)
return err
}
return nil
}

51
object/ldap_conn.go
View File

@ -255,8 +255,12 @@ func SyncLdapUsers(owner string, syncUsers []LdapUser, ldapId string) (existUser
uuids = append(uuids, user.Uuid)
}
organization := getOrganization("admin", owner)
ldap := GetLdap(ldapId)
organization, err := getOrganization("admin", owner)
if err != nil {
panic(err)
}
ldap, err := GetLdap(ldapId)
var dc []string
for _, basedn := range strings.Split(ldap.BaseDn, ",") {
@ -275,7 +279,11 @@ func SyncLdapUsers(owner string, syncUsers []LdapUser, ldapId string) (existUser
tag := strings.Join(ou, ".")
for _, syncUser := range syncUsers {
existUuids := GetExistUuids(owner, uuids)
existUuids, err := GetExistUuids(owner, uuids)
if err != nil {
return nil, nil, err
}
found := false
if len(existUuids) > 0 {
for _, existUuid := range existUuids {
@ -287,10 +295,19 @@ func SyncLdapUsers(owner string, syncUsers []LdapUser, ldapId string) (existUser
}
if !found {
score, _ := organization.GetInitScore()
score, err := organization.GetInitScore()
if err != nil {
return nil, nil, err
}
name, err := syncUser.buildLdapUserName()
if err != nil {
return nil, nil, err
}
newUser := &User{
Owner: owner,
Name: syncUser.buildLdapUserName(),
Name: name,
CreatedTime: util.GetCurrentTime(),
DisplayName: syncUser.buildLdapDisplayName(),
Avatar: organization.DefaultAvatar,
@ -303,7 +320,11 @@ func SyncLdapUsers(owner string, syncUsers []LdapUser, ldapId string) (existUser
Ldap: syncUser.Uuid,
}
affected := AddUser(newUser)
affected, err := AddUser(newUser)
if err != nil {
return nil, nil, err
}
if !affected {
failedUsers = append(failedUsers, syncUser)
continue
@ -314,38 +335,38 @@ func SyncLdapUsers(owner string, syncUsers []LdapUser, ldapId string) (existUser
return existUsers, failedUsers, err
}
func GetExistUuids(owner string, uuids []string) []string {
func GetExistUuids(owner string, uuids []string) ([]string, error) {
var existUuids []string
err := adapter.Engine.Table("user").Where("owner = ?", owner).Cols("ldap").
In("ldap", uuids).Select("DISTINCT ldap").Find(&existUuids)
if err != nil {
panic(err)
return existUuids, err
}
return existUuids
return existUuids, nil
}
func (ldapUser *LdapUser) buildLdapUserName() string {
func (ldapUser *LdapUser) buildLdapUserName() (string, error) {
user := User{}
uidWithNumber := fmt.Sprintf("%s_%s", ldapUser.Uid, ldapUser.UidNumber)
has, err := adapter.Engine.Where("name = ? or name = ?", ldapUser.Uid, uidWithNumber).Get(&user)
if err != nil {
panic(err)
return "", err
}
if has {
if user.Name == ldapUser.Uid {
return uidWithNumber
return uidWithNumber, nil
}
return fmt.Sprintf("%s_%s", uidWithNumber, randstr.Hex(6))
return fmt.Sprintf("%s_%s", uidWithNumber, randstr.Hex(6)), nil
}
if ldapUser.Uid != "" {
return ldapUser.Uid
return ldapUser.Uid, nil
}
return ldapUser.Cn
return ldapUser.Cn, nil
}
func (ldapUser *LdapUser) buildLdapDisplayName() string {

75
object/message.go
View File

@ -48,109 +48,94 @@ func GetMaskedMessages(messages []*Message) []*Message {
return messages
}
func GetMessageCount(owner, organization, field, value string) int {
func GetMessageCount(owner, organization, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Message{Organization: organization})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Message{Organization: organization})
}
func GetMessages(owner string) []*Message {
func GetMessages(owner string) ([]*Message, error) {
messages := []*Message{}
err := adapter.Engine.Desc("created_time").Find(&messages, &Message{Owner: owner})
if err != nil {
panic(err)
}
return messages
return messages, err
}
func GetChatMessages(chat string) []*Message {
func GetChatMessages(chat string) ([]*Message, error) {
messages := []*Message{}
err := adapter.Engine.Asc("created_time").Find(&messages, &Message{Chat: chat})
if err != nil {
panic(err)
}
return messages
return messages, err
}
func GetPaginationMessages(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) []*Message {
func GetPaginationMessages(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) ([]*Message, error) {
messages := []*Message{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&messages, &Message{Organization: organization})
if err != nil {
panic(err)
}
return messages
return messages, err
}
func getMessage(owner string, name string) *Message {
func getMessage(owner string, name string) (*Message, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
message := Message{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&message)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &message
return &message, nil
} else {
return nil
return nil, nil
}
}
func GetMessage(id string) *Message {
func GetMessage(id string) (*Message, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getMessage(owner, name)
}
func UpdateMessage(id string, message *Message) bool {
func UpdateMessage(id string, message *Message) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getMessage(owner, name) == nil {
return false
if m, err := getMessage(owner, name); err != nil {
return false, err
} else if m == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(message)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddMessage(message *Message) bool {
func AddMessage(message *Message) (bool, error) {
affected, err := adapter.Engine.Insert(message)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteMessage(message *Message) bool {
func DeleteMessage(message *Message) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{message.Owner, message.Name}).Delete(&Message{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteChatMessages(chat string) bool {
func DeleteChatMessages(chat string) (bool, error) {
affected, err := adapter.Engine.Delete(&Message{Chat: chat})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (p *Message) GetId() string {

6
object/mfa.go
View File

@ -83,7 +83,11 @@ func RecoverTfs(user *User, recoveryCode string) error {
return fmt.Errorf("recovery code not found")
}
affected := UpdateUser(user.GetId(), user, []string{"two_factor_auth"}, user.IsAdminUser())
affected, err := UpdateUser(user.GetId(), user, []string{"two_factor_auth"}, user.IsAdminUser())
if err != nil {
return err
}
if !affected {
return fmt.Errorf("")
}

6
object/mfa_sms.go
View File

@ -100,7 +100,11 @@ func (mfa *SmsMfa) Enable(ctx *context.Context, user *User) error {
}
user.MultiFactorAuths = append(user.MultiFactorAuths, mfa.Config)
affected := UpdateUser(user.GetId(), user, []string{"multi_factor_auths"}, user.IsAdminUser())
affected, err := UpdateUser(user.GetId(), user, []string{"multi_factor_auths"}, user.IsAdminUser())
if err != nil {
return err
}
if !affected {
return fmt.Errorf("failed to enable two factor authentication")
}

5
object/migrator.go
View File

@ -44,5 +44,8 @@ func DoMigration() {
}
m := migrate.New(adapter.Engine, options, migrations)
m.Migrate()
err := m.Migrate()
if err != nil {
panic(err)
}
}

64
object/model.go
View File

@ -32,56 +32,51 @@ type Model struct {
IsEnabled bool `json:"isEnabled"`
}
func GetModelCount(owner, field, value string) int {
func GetModelCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Model{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Model{})
}
func GetModels(owner string) []*Model {
func GetModels(owner string) ([]*Model, error) {
models := []*Model{}
err := adapter.Engine.Desc("created_time").Find(&models, &Model{Owner: owner})
if err != nil {
panic(err)
return models, err
}
return models
return models, nil
}
func GetPaginationModels(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Model {
func GetPaginationModels(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Model, error) {
models := []*Model{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&models)
if err != nil {
panic(err)
return models, err
}
return models
return models, nil
}
func getModel(owner string, name string) *Model {
func getModel(owner string, name string) (*Model, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
m := Model{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&m)
if err != nil {
panic(err)
return &m, err
}
if existed {
return &m
return &m, nil
} else {
return nil
return nil, nil
}
}
func GetModel(id string) *Model {
func GetModel(id string) (*Model, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getModel(owner, name)
}
@ -92,48 +87,53 @@ func UpdateModelWithCheck(id string, modelObj *Model) error {
if err != nil {
return err
}
UpdateModel(id, modelObj)
_, err = UpdateModel(id, modelObj)
if err != nil {
return err
}
return nil
}
func UpdateModel(id string, modelObj *Model) bool {
func UpdateModel(id string, modelObj *Model) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getModel(owner, name) == nil {
return false
if m, err := getModel(owner, name); err != nil {
return false, err
} else if m == nil {
return false, nil
}
if name != modelObj.Name {
err := modelChangeTrigger(name, modelObj.Name)
if err != nil {
return false
return false, err
}
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(modelObj)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, err
}
func AddModel(model *Model) bool {
func AddModel(model *Model) (bool, error) {
affected, err := adapter.Engine.Insert(model)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteModel(model *Model) bool {
func DeleteModel(model *Model) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{model.Owner, model.Name}).Delete(&Model{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (model *Model) GetId() string {

6
object/oidc_discovery.go
View File

@ -110,8 +110,12 @@ func GetOidcDiscovery(host string) OidcDiscovery {
}
func GetJsonWebKeySet() (jose.JSONWebKeySet, error) {
certs := GetCerts("admin")
jwks := jose.JSONWebKeySet{}
certs, err := GetCerts("admin")
if err != nil {
return jwks, err
}
// follows the protocol rfc 7517(draft)
// link here: https://self-issued.info/docs/draft-ietf-jose-json-web-key.html
// or https://datatracker.ietf.org/doc/html/draft-ietf-jose-json-web-key

123
object/organization.go
View File

@ -70,92 +70,102 @@ type Organization struct {
AccountItems []*AccountItem `xorm:"varchar(3000)" json:"accountItems"`
}
func GetOrganizationCount(owner, field, value string) int {
func GetOrganizationCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Organization{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Organization{})
}
func GetOrganizations(owner string) []*Organization {
func GetOrganizations(owner string) ([]*Organization, error) {
organizations := []*Organization{}
err := adapter.Engine.Desc("created_time").Find(&organizations, &Organization{Owner: owner})
if err != nil {
panic(err)
return nil, err
}
return organizations
return organizations, nil
}
func GetOrganizationsByFields(owner string, fields ...string) []*Organization {
func GetOrganizationsByFields(owner string, fields ...string) ([]*Organization, error) {
organizations := []*Organization{}
err := adapter.Engine.Desc("created_time").Cols(fields...).Find(&organizations, &Organization{Owner: owner})
if err != nil {
panic(err)
return nil, err
}
return organizations
return organizations, nil
}
func GetPaginationOrganizations(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Organization {
func GetPaginationOrganizations(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Organization, error) {
organizations := []*Organization{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&organizations)
if err != nil {
panic(err)
return nil, err
}
return organizations
return organizations, nil
}
func getOrganization(owner string, name string) *Organization {
func getOrganization(owner string, name string) (*Organization, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
organization := Organization{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&organization)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &organization
return &organization, nil
}
return nil
return nil, nil
}
func GetOrganization(id string) *Organization {
func GetOrganization(id string) (*Organization, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getOrganization(owner, name)
}
func GetMaskedOrganization(organization *Organization) *Organization {
func GetMaskedOrganization(organization *Organization, errs ...error) (*Organization, error) {
if len(errs) > 0 && errs[0] != nil {
return nil, errs[0]
}
if organization == nil {
return nil
return nil, nil
}
if organization.MasterPassword != "" {
organization.MasterPassword = "***"
}
return organization
return organization, nil
}
func GetMaskedOrganizations(organizations []*Organization) []*Organization {
for _, organization := range organizations {
organization = GetMaskedOrganization(organization)
func GetMaskedOrganizations(organizations []*Organization, errs ...error) ([]*Organization, error) {
if len(errs) > 0 && errs[0] != nil {
return nil, errs[0]
}
return organizations
var err error
for _, organization := range organizations {
organization, err = GetMaskedOrganization(organization)
if err != nil {
return nil, err
}
}
return organizations, nil
}
func UpdateOrganization(id string, organization *Organization) bool {
func UpdateOrganization(id string, organization *Organization) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getOrganization(owner, name) == nil {
return false
if org, err := getOrganization(owner, name); err != nil {
return false, err
} else if org == nil {
return false, nil
}
if name == "built-in" {
@ -165,7 +175,7 @@ func UpdateOrganization(id string, organization *Organization) bool {
if name != organization.Name {
err := organizationChangeTrigger(name, organization.Name)
if err != nil {
return false
return false, nil
}
}
@ -183,35 +193,35 @@ func UpdateOrganization(id string, organization *Organization) bool {
}
affected, err := session.Update(organization)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddOrganization(organization *Organization) bool {
func AddOrganization(organization *Organization) (bool, error) {
affected, err := adapter.Engine.Insert(organization)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteOrganization(organization *Organization) bool {
func DeleteOrganization(organization *Organization) (bool, error) {
if organization.Name == "built-in" {
return false
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{organization.Owner, organization.Name}).Delete(&Organization{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func GetOrganizationByUser(user *User) *Organization {
func GetOrganizationByUser(user *User) (*Organization, error) {
return getOrganization("admin", user.Owner)
}
@ -248,13 +258,21 @@ func CheckAccountItemModifyRule(accountItem *AccountItem, isAdmin bool, lang str
}
func GetDefaultApplication(id string) (*Application, error) {
organization := GetOrganization(id)
organization, err := GetOrganization(id)
if err != nil {
return nil, err
}
if organization == nil {
return nil, fmt.Errorf("The organization: %s does not exist", id)
}
if organization.DefaultApplication != "" {
defaultApplication := getApplication("admin", organization.DefaultApplication)
defaultApplication, err := getApplication("admin", organization.DefaultApplication)
if err != nil {
return nil, err
}
if defaultApplication == nil {
return nil, fmt.Errorf("The default application: %s does not exist", organization.DefaultApplication)
} else {
@ -263,9 +281,9 @@ func GetDefaultApplication(id string) (*Application, error) {
}
applications := []*Application{}
err := adapter.Engine.Asc("created_time").Find(&applications, &Application{Organization: organization.Name})
err = adapter.Engine.Asc("created_time").Find(&applications, &Application{Organization: organization.Name})
if err != nil {
panic(err)
return nil, err
}
if len(applications) == 0 {
@ -280,8 +298,15 @@ func GetDefaultApplication(id string) (*Application, error) {
}
}
extendApplicationWithProviders(defaultApplication)
extendApplicationWithOrg(defaultApplication)
err = extendApplicationWithProviders(defaultApplication)
if err != nil {
return nil, err
}
err = extendApplicationWithOrg(defaultApplication)
if err != nil {
return nil, err
}
return defaultApplication, nil
}

95
object/payment.go
View File

@ -56,74 +56,71 @@ type Payment struct {
InvoiceUrl string `xorm:"varchar(255)" json:"invoiceUrl"`
}
func GetPaymentCount(owner, field, value string) int {
func GetPaymentCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Payment{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Payment{})
}
func GetPayments(owner string) []*Payment {
func GetPayments(owner string) ([]*Payment, error) {
payments := []*Payment{}
err := adapter.Engine.Desc("created_time").Find(&payments, &Payment{Owner: owner})
if err != nil {
panic(err)
return nil, err
}
return payments
return payments, nil
}
func GetUserPayments(owner string, organization string, user string) []*Payment {
func GetUserPayments(owner string, organization string, user string) ([]*Payment, error) {
payments := []*Payment{}
err := adapter.Engine.Desc("created_time").Find(&payments, &Payment{Owner: owner, Organization: organization, User: user})
if err != nil {
panic(err)
return nil, err
}
return payments
return payments, nil
}
func GetPaginationPayments(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Payment {
func GetPaginationPayments(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Payment, error) {
payments := []*Payment{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&payments)
if err != nil {
panic(err)
return nil, err
}
return payments
return payments, nil
}
func getPayment(owner string, name string) *Payment {
func getPayment(owner string, name string) (*Payment, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
payment := Payment{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&payment)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &payment
return &payment, nil
} else {
return nil
return nil, nil
}
}
func GetPayment(id string) *Payment {
func GetPayment(id string) (*Payment, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getPayment(owner, name)
}
func UpdatePayment(id string, payment *Payment) bool {
func UpdatePayment(id string, payment *Payment) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getPayment(owner, name) == nil {
return false
if p, err := getPayment(owner, name); err != nil {
return false, err
} else if p == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(payment)
@ -131,42 +128,53 @@ func UpdatePayment(id string, payment *Payment) bool {
panic(err)
}
return affected != 0
return affected != 0, nil
}
func AddPayment(payment *Payment) bool {
func AddPayment(payment *Payment) (bool, error) {
affected, err := adapter.Engine.Insert(payment)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeletePayment(payment *Payment) bool {
func DeletePayment(payment *Payment) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{payment.Owner, payment.Name}).Delete(&Payment{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func notifyPayment(request *http.Request, body []byte, owner string, providerName string, productName string, paymentName string) (*Payment, error, string) {
provider := getProvider(owner, providerName)
provider, err := getProvider(owner, providerName)
if err != nil {
panic(err)
}
pProvider, cert, err := provider.getPaymentProvider()
if err != nil {
panic(err)
}
payment := getPayment(owner, paymentName)
payment, err := getPayment(owner, paymentName)
if err != nil {
panic(err)
}
if payment == nil {
err = fmt.Errorf("the payment: %s does not exist", paymentName)
return nil, err, pProvider.GetResponseError(err)
}
product := getProduct(owner, productName)
product, err := getProduct(owner, productName)
if err != nil {
panic(err)
}
if product == nil {
err = fmt.Errorf("the product: %s does not exist", productName)
return payment, err, pProvider.GetResponseError(err)
@ -201,14 +209,21 @@ func NotifyPayment(request *http.Request, body []byte, owner string, providerNam
payment.State = "Paid"
}
UpdatePayment(payment.GetId(), payment)
_, err = UpdatePayment(payment.GetId(), payment)
if err != nil {
panic(err)
}
}
return err, errorResponse
}
func invoicePayment(payment *Payment) (string, error) {
provider := getProvider(payment.Owner, payment.Provider)
provider, err := getProvider(payment.Owner, payment.Provider)
if err != nil {
panic(err)
}
if provider == nil {
return "", fmt.Errorf("the payment provider: %s does not exist", payment.Provider)
}
@ -237,7 +252,11 @@ func InvoicePayment(payment *Payment) (string, error) {
}
payment.InvoiceUrl = invoiceUrl
affected := UpdatePayment(payment.GetId(), payment)
affected, err := UpdatePayment(payment.GetId(), payment)
if err != nil {
return "", err
}
if !affected {
return "", fmt.Errorf("failed to update the payment: %s", payment.Name)
}

105
object/permission.go
View File

@ -66,96 +66,97 @@ func (p *Permission) GetId() string {
return util.GetId(p.Owner, p.Name)
}
func GetPermissionCount(owner, field, value string) int {
func GetPermissionCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Permission{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Permission{})
}
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 GetPaginationPermissions(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Permission {
func GetPaginationPermissions(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Permission, error) {
permissions := []*Permission{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&permissions)
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)
}
// checkPermissionValid verifies if the permission is valid
func checkPermissionValid(permission *Permission) {
func checkPermissionValid(permission *Permission) error {
enforcer := getEnforcer(permission)
enforcer.EnableAutoSave(false)
policies := getPolicies(permission)
_, err := enforcer.AddPolicies(policies)
if err != nil {
panic(err)
return err
}
if !HasRoleDefinition(enforcer.GetModel()) {
permission.Roles = []string{}
return
return nil
}
groupingPolicies := getGroupingPolicies(permission)
if len(groupingPolicies) > 0 {
_, err := enforcer.AddGroupingPolicies(groupingPolicies)
if err != nil {
panic(err)
return err
}
}
return nil
}
func UpdatePermission(id string, permission *Permission) bool {
checkPermissionValid(permission)
func UpdatePermission(id string, permission *Permission) (bool, error) {
err := checkPermissionValid(permission)
if err != nil {
return false, err
}
owner, name := util.GetOwnerAndNameFromId(id)
oldPermission := getPermission(owner, name)
oldPermission, err := getPermission(owner, name)
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
}
if affected != 0 {
@ -166,7 +167,7 @@ func UpdatePermission(id string, permission *Permission) bool {
if isEmpty {
err = adapter.Engine.DropTables(oldPermission.Adapter)
if err != nil {
panic(err)
return false, err
}
}
}
@ -174,13 +175,13 @@ func UpdatePermission(id string, permission *Permission) bool {
addPolicies(permission)
}
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
}
if affected != 0 {
@ -188,7 +189,7 @@ func AddPermission(permission *Permission) bool {
addPolicies(permission)
}
return affected != 0
return affected != 0, nil
}
func AddPermissions(permissions []*Permission) bool {
@ -239,10 +240,10 @@ func AddPermissionsInBatch(permissions []*Permission) bool {
return affected
}
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
}
if affected != 0 {
@ -253,67 +254,67 @@ func DeletePermission(permission *Permission) bool {
if isEmpty {
err = adapter.Engine.DropTables(permission.Adapter)
if err != nil {
panic(err)
return false, err
}
}
}
}
return affected != 0
return affected != 0, nil
}
func GetPermissionsByUser(userId string) []*Permission {
func GetPermissionsByUser(userId string) ([]*Permission, error) {
permissions := []*Permission{}
err := adapter.Engine.Where("users like ?", "%"+userId+"\"%").Find(&permissions)
if err != nil {
panic(err)
return permissions, err
}
for i := range permissions {
permissions[i].Users = nil
}
return permissions
return permissions, nil
}
func GetPermissionsByRole(roleId string) []*Permission {
func GetPermissionsByRole(roleId string) ([]*Permission, error) {
permissions := []*Permission{}
err := adapter.Engine.Where("roles like ?", "%"+roleId+"\"%").Find(&permissions)
if err != nil {
panic(err)
return permissions, err
}
return permissions
return permissions, nil
}
func GetPermissionsByResource(resourceId string) []*Permission {
func GetPermissionsByResource(resourceId string) ([]*Permission, error) {
permissions := []*Permission{}
err := adapter.Engine.Where("resources like ?", "%"+resourceId+"\"%").Find(&permissions)
if err != nil {
panic(err)
return permissions, err
}
return permissions
return permissions, nil
}
func GetPermissionsBySubmitter(owner string, submitter string) []*Permission {
func GetPermissionsBySubmitter(owner string, submitter string) ([]*Permission, error) {
permissions := []*Permission{}
err := adapter.Engine.Desc("created_time").Find(&permissions, &Permission{Owner: owner, Submitter: submitter})
if err != nil {
panic(err)
return permissions, err
}
return permissions
return permissions, nil
}
func GetPermissionsByModel(owner string, model string) []*Permission {
func GetPermissionsByModel(owner string, model string) ([]*Permission, error) {
permissions := []*Permission{}
err := adapter.Engine.Desc("created_time").Find(&permissions, &Permission{Owner: owner, Model: model})
if err != nil {
panic(err)
return permissions, err
}
return permissions
return permissions, nil
}
func ContainsAsterisk(userId string, users []string) bool {

68
object/permission_enforcer.go
View File

@ -29,7 +29,11 @@ import (
func getEnforcer(permission *Permission) *casbin.Enforcer {
tableName := "permission_rule"
if len(permission.Adapter) != 0 {
adapterObj := getCasbinAdapter(permission.Owner, permission.Adapter)
adapterObj, err := getCasbinAdapter(permission.Owner, permission.Adapter)
if err != nil {
panic(err)
}
if adapterObj != nil && adapterObj.Table != "" {
tableName = adapterObj.Table
}
@ -42,7 +46,11 @@ func getEnforcer(permission *Permission) *casbin.Enforcer {
panic(err)
}
permissionModel := getModel(permission.Owner, permission.Model)
permissionModel, err := getModel(permission.Owner, permission.Model)
if err != nil {
panic(err)
}
m := model.Model{}
if permissionModel != nil {
m, err = GetBuiltInModel(permissionModel.ModelText)
@ -122,21 +130,30 @@ func getPolicies(permission *Permission) [][]string {
return policies
}
func getRolesInRole(roleId string, visited map[string]struct{}) []*Role {
role := GetRole(roleId)
func getRolesInRole(roleId string, visited map[string]struct{}) ([]*Role, error) {
role, err := GetRole(roleId)
if err != nil {
return []*Role{}, err
}
if role == nil {
return []*Role{}
return []*Role{}, nil
}
visited[roleId] = struct{}{}
roles := []*Role{role}
for _, subRole := range role.Roles {
if _, ok := visited[subRole]; !ok {
roles = append(roles, getRolesInRole(subRole, visited)...)
r, err := getRolesInRole(subRole, visited)
if err != nil {
return []*Role{}, err
}
roles = append(roles, r...)
}
}
return roles
return roles, nil
}
func getGroupingPolicies(permission *Permission) [][]string {
@ -147,8 +164,10 @@ func getGroupingPolicies(permission *Permission) [][]string {
for _, roleId := range permission.Roles {
visited := map[string]struct{}{}
rolesInRole := getRolesInRole(roleId, visited)
rolesInRole, err := getRolesInRole(roleId, visited)
if err != nil {
panic(err)
}
for _, role := range rolesInRole {
roleId := role.GetId()
for _, subUser := range role.Users {
@ -223,7 +242,11 @@ func removePolicies(permission *Permission) {
type CasbinRequest = []interface{}
func Enforce(permissionId string, request *CasbinRequest) bool {
permission := GetPermission(permissionId)
permission, err := GetPermission(permissionId)
if err != nil {
panic(err)
}
enforcer := getEnforcer(permission)
allow, err := enforcer.Enforce(*request...)
@ -234,7 +257,11 @@ func Enforce(permissionId string, request *CasbinRequest) bool {
}
func BatchEnforce(permissionId string, requests *[]CasbinRequest) []bool {
permission := GetPermission(permissionId)
permission, err := GetPermission(permissionId)
if err != nil {
panic(err)
}
enforcer := getEnforcer(permission)
allow, err := enforcer.BatchEnforce(*requests)
if err != nil {
@ -244,9 +271,18 @@ func BatchEnforce(permissionId string, requests *[]CasbinRequest) []bool {
}
func getAllValues(userId string, fn func(enforcer *casbin.Enforcer) []string) []string {
permissions := GetPermissionsByUser(userId)
permissions, err := GetPermissionsByUser(userId)
if err != nil {
panic(err)
}
for _, role := range GetAllRoles(userId) {
permissions = append(permissions, GetPermissionsByRole(role)...)
permissionsByRole, err := GetPermissionsByRole(role)
if err != nil {
panic(err)
}
permissions = append(permissions, permissionsByRole...)
}
var values []string
@ -270,7 +306,11 @@ func GetAllActions(userId string) []string {
}
func GetAllRoles(userId string) []string {
roles := GetRolesByUser(userId)
roles, err := GetRolesByUser(userId)
if err != nil {
panic(err)
}
var res []string
for _, role := range roles {
res = append(res, role.Name)

22
object/permission_upload.go
View File

@ -18,21 +18,29 @@ import (
"github.com/casdoor/casdoor/xlsx"
)
func getPermissionMap(owner string) map[string]*Permission {
func getPermissionMap(owner string) (map[string]*Permission, error) {
m := map[string]*Permission{}
permissions := GetPermissions(owner)
permissions, err := GetPermissions(owner)
if err != nil {
return nil, err
}
for _, permission := range permissions {
m[permission.GetId()] = permission
}
return m
return m, err
}
func UploadPermissions(owner string, fileId string) bool {
func UploadPermissions(owner string, fileId string) (bool, error) {
table := xlsx.ReadXlsxFile(fileId)
oldUserMap := getPermissionMap(owner)
oldUserMap, err := getPermissionMap(owner)
if err != nil {
return false, err
}
newPermissions := []*Permission{}
for index, line := range table {
if index == 0 || parseLineItem(&line, 0) == "" {
@ -71,7 +79,7 @@ func UploadPermissions(owner string, fileId string) bool {
}
if len(newPermissions) == 0 {
return false
return false, nil
}
return AddPermissionsInBatch(newPermissions)
return AddPermissionsInBatch(newPermissions), nil
}

80
object/plan.go
View File

@ -37,109 +37,115 @@ type Plan struct {
Options []string `xorm:"-" json:"options"`
}
func GetPlanCount(owner, field, value string) int {
func GetPlanCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Plan{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Plan{})
}
func GetPlans(owner string) []*Plan {
func GetPlans(owner string) ([]*Plan, error) {
plans := []*Plan{}
err := adapter.Engine.Desc("created_time").Find(&plans, &Plan{Owner: owner})
if err != nil {
panic(err)
return plans, err
}
return plans
return plans, nil
}
func GetPaginatedPlans(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Plan {
func GetPaginatedPlans(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Plan, error) {
plans := []*Plan{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&plans)
if err != nil {
panic(err)
return plans, err
}
return plans
return plans, nil
}
func getPlan(owner, name string) *Plan {
func getPlan(owner, name string) (*Plan, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
plan := Plan{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&plan)
if err != nil {
panic(err)
return &plan, err
}
if existed {
return &plan
return &plan, nil
} else {
return nil
return nil, nil
}
}
func GetPlan(id string) *Plan {
func GetPlan(id string) (*Plan, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getPlan(owner, name)
}
func UpdatePlan(id string, plan *Plan) bool {
func UpdatePlan(id string, plan *Plan) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getPlan(owner, name) == nil {
return false
if p, err := getPlan(owner, name); err != nil {
return false, err
} else if p == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(plan)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddPlan(plan *Plan) bool {
func AddPlan(plan *Plan) (bool, error) {
affected, err := adapter.Engine.Insert(plan)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeletePlan(plan *Plan) bool {
func DeletePlan(plan *Plan) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{plan.Owner, plan.Name}).Delete(plan)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (plan *Plan) GetId() string {
return fmt.Sprintf("%s/%s", plan.Owner, plan.Name)
}
func Subscribe(owner string, user string, plan string, pricing string) *Subscription {
selectedPricing := GetPricing(fmt.Sprintf("%s/%s", owner, pricing))
func Subscribe(owner string, user string, plan string, pricing string) (*Subscription, error) {
selectedPricing, err := GetPricing(fmt.Sprintf("%s/%s", owner, pricing))
if err != nil {
return nil, err
}
valid := selectedPricing != nil && selectedPricing.IsEnabled
if !valid {
return nil
return nil, nil
}
planBelongToPricing := selectedPricing.HasPlan(owner, plan)
planBelongToPricing, err := selectedPricing.HasPlan(owner, plan)
if err != nil {
return nil, err
}
if planBelongToPricing {
newSubscription := NewSubscription(owner, user, plan, selectedPricing.TrialDuration)
affected := AddSubscription(newSubscription)
affected, err := AddSubscription(newSubscription)
if err != nil {
return nil, err
}
if affected {
return newSubscription
return newSubscription, nil
}
}
return nil
return nil, nil
}

69
object/pricing.go
View File

@ -42,96 +42,97 @@ type Pricing struct {
State string `xorm:"varchar(100)" json:"state"`
}
func GetPricingCount(owner, field, value string) int {
func GetPricingCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Pricing{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Pricing{})
}
func GetPricings(owner string) []*Pricing {
func GetPricings(owner string) ([]*Pricing, error) {
pricings := []*Pricing{}
err := adapter.Engine.Desc("created_time").Find(&pricings, &Pricing{Owner: owner})
if err != nil {
panic(err)
return pricings, err
}
return pricings
return pricings, nil
}
func GetPaginatedPricings(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Pricing {
func GetPaginatedPricings(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Pricing, error) {
pricings := []*Pricing{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&pricings)
if err != nil {
panic(err)
return pricings, err
}
return pricings
return pricings, nil
}
func getPricing(owner, name string) *Pricing {
func getPricing(owner, name string) (*Pricing, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
pricing := Pricing{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&pricing)
if err != nil {
panic(err)
return &pricing, err
}
if existed {
return &pricing
return &pricing, nil
} else {
return nil
return nil, nil
}
}
func GetPricing(id string) *Pricing {
func GetPricing(id string) (*Pricing, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getPricing(owner, name)
}
func UpdatePricing(id string, pricing *Pricing) bool {
func UpdatePricing(id string, pricing *Pricing) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getPricing(owner, name) == nil {
return false
if p, err := getPricing(owner, name); err != nil {
return false, err
} else if p == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(pricing)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddPricing(pricing *Pricing) bool {
func AddPricing(pricing *Pricing) (bool, error) {
affected, err := adapter.Engine.Insert(pricing)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeletePricing(pricing *Pricing) bool {
func DeletePricing(pricing *Pricing) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{pricing.Owner, pricing.Name}).Delete(pricing)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (pricing *Pricing) GetId() string {
return fmt.Sprintf("%s/%s", pricing.Owner, pricing.Name)
}
func (pricing *Pricing) HasPlan(owner string, plan string) bool {
selectedPlan := GetPlan(fmt.Sprintf("%s/%s", owner, plan))
func (pricing *Pricing) HasPlan(owner string, plan string) (bool, error) {
selectedPlan, err := GetPlan(fmt.Sprintf("%s/%s", owner, plan))
if err != nil {
return false, err
}
if selectedPlan == nil {
return false
return false, nil
}
result := false
@ -143,5 +144,5 @@ func (pricing *Pricing) HasPlan(owner string, plan string) bool {
}
}
return result
return result, nil
}

87
object/product.go
View File

@ -43,90 +43,87 @@ type Product struct {
ProviderObjs []*Provider `xorm:"-" json:"providerObjs"`
}
func GetProductCount(owner, field, value string) int {
func GetProductCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Product{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Product{})
}
func GetProducts(owner string) []*Product {
func GetProducts(owner string) ([]*Product, error) {
products := []*Product{}
err := adapter.Engine.Desc("created_time").Find(&products, &Product{Owner: owner})
if err != nil {
panic(err)
return products, err
}
return products
return products, nil
}
func GetPaginationProducts(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Product {
func GetPaginationProducts(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Product, error) {
products := []*Product{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&products)
if err != nil {
panic(err)
return products, err
}
return products
return products, nil
}
func getProduct(owner string, name string) *Product {
func getProduct(owner string, name string) (*Product, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
product := Product{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&product)
if err != nil {
panic(err)
return &product, nil
}
if existed {
return &product
return &product, nil
} else {
return nil
return nil, nil
}
}
func GetProduct(id string) *Product {
func GetProduct(id string) (*Product, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getProduct(owner, name)
}
func UpdateProduct(id string, product *Product) bool {
func UpdateProduct(id string, product *Product) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getProduct(owner, name) == nil {
return false
if p, err := getProduct(owner, name); err != nil {
return false, err
} else if p == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(product)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddProduct(product *Product) bool {
func AddProduct(product *Product) (bool, error) {
affected, err := adapter.Engine.Insert(product)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteProduct(product *Product) bool {
func DeleteProduct(product *Product) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{product.Owner, product.Name}).Delete(&Product{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (product *Product) GetId() string {
@ -143,7 +140,11 @@ func (product *Product) isValidProvider(provider *Provider) bool {
}
func (product *Product) getProvider(providerId string) (*Provider, error) {
provider := getProvider(product.Owner, providerId)
provider, err := getProvider(product.Owner, providerId)
if err != nil {
return nil, err
}
if provider == nil {
return nil, fmt.Errorf("the payment provider: %s does not exist", providerId)
}
@ -156,7 +157,11 @@ func (product *Product) getProvider(providerId string) (*Provider, error) {
}
func BuyProduct(id string, providerName string, user *User, host string) (string, error) {
product := GetProduct(id)
product, err := GetProduct(id)
if err != nil {
return "", err
}
if product == nil {
return "", fmt.Errorf("the product: %s does not exist", id)
}
@ -205,7 +210,11 @@ func BuyProduct(id string, providerName string, user *User, host string) (string
ReturnUrl: product.ReturnUrl,
State: "Created",
}
affected := AddPayment(&payment)
affected, err := AddPayment(&payment)
if err != nil {
return "", err
}
if !affected {
return "", fmt.Errorf("failed to add payment: %s", util.StructToJson(payment))
}
@ -213,17 +222,23 @@ func BuyProduct(id string, providerName string, user *User, host string) (string
return payUrl, err
}
func ExtendProductWithProviders(product *Product) {
func ExtendProductWithProviders(product *Product) error {
if product == nil {
return
return nil
}
product.ProviderObjs = []*Provider{}
m := getProviderMap(product.Owner)
m, err := getProviderMap(product.Owner)
if err != nil {
return err
}
for _, providerItem := range product.Providers {
if provider, ok := m[providerItem]; ok {
product.ProviderObjs = append(product.ProviderObjs, provider)
}
}
return nil
}

6
object/product_test.go
View File

@ -27,9 +27,9 @@ import (
func TestProduct(t *testing.T) {
InitConfig()
product := GetProduct("admin/product_123")
provider := getProvider(product.Owner, "provider_pay_alipay")
cert := getCert(product.Owner, "cert-pay-alipay")
product, _ := GetProduct("admin/product_123")
provider, _ := getProvider(product.Owner, "provider_pay_alipay")
cert, _ := getCert(product.Owner, "cert-pay-alipay")
pProvider, err := pp.GetPaymentProvider(provider.Type, provider.ClientId, provider.ClientSecret, provider.Host, cert.Certificate, cert.PrivateKey, cert.AuthorityPublicKey, cert.AuthorityRootPublicKey, provider.ClientId2)
if err != nil {
panic(err)

100
object/provider.go
View File

@ -103,103 +103,93 @@ func GetMaskedProviders(providers []*Provider, isMaskEnabled bool) []*Provider {
return providers
}
func GetProviderCount(owner, field, value string) int {
func GetProviderCount(owner, field, value string) (int64, error) {
session := GetSession("", -1, -1, field, value, "", "")
count, err := session.Where("owner = ? or owner = ? ", "admin", owner).Count(&Provider{})
if err != nil {
panic(err)
}
return int(count)
return session.Where("owner = ? or owner = ? ", "admin", owner).Count(&Provider{})
}
func GetGlobalProviderCount(field, value string) int {
func GetGlobalProviderCount(field, value string) (int64, error) {
session := GetSession("", -1, -1, field, value, "", "")
count, err := session.Count(&Provider{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Provider{})
}
func GetProviders(owner string) []*Provider {
func GetProviders(owner string) ([]*Provider, error) {
providers := []*Provider{}
err := adapter.Engine.Where("owner = ? or owner = ? ", "admin", owner).Desc("created_time").Find(&providers, &Provider{})
if err != nil {
panic(err)
return providers, err
}
return providers
return providers, nil
}
func GetGlobalProviders() []*Provider {
func GetGlobalProviders() ([]*Provider, error) {
providers := []*Provider{}
err := adapter.Engine.Desc("created_time").Find(&providers)
if err != nil {
panic(err)
return providers, err
}
return providers
return providers, nil
}
func GetPaginationProviders(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Provider {
func GetPaginationProviders(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Provider, error) {
providers := []*Provider{}
session := GetSession("", offset, limit, field, value, sortField, sortOrder)
err := session.Where("owner = ? or owner = ? ", "admin", owner).Find(&providers)
if err != nil {
panic(err)
return providers, err
}
return providers
return providers, nil
}
func GetPaginationGlobalProviders(offset, limit int, field, value, sortField, sortOrder string) []*Provider {
func GetPaginationGlobalProviders(offset, limit int, field, value, sortField, sortOrder string) ([]*Provider, error) {
providers := []*Provider{}
session := GetSession("", offset, limit, field, value, sortField, sortOrder)
err := session.Find(&providers)
if err != nil {
panic(err)
return providers, err
}
return providers
return providers, nil
}
func getProvider(owner string, name string) *Provider {
func getProvider(owner string, name string) (*Provider, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
provider := Provider{Name: name}
existed, err := adapter.Engine.Get(&provider)
if err != nil {
panic(err)
return &provider, err
}
if existed {
return &provider
return &provider, nil
} else {
return nil
return nil, nil
}
}
func GetProvider(id string) *Provider {
func GetProvider(id string) (*Provider, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getProvider(owner, name)
}
func getDefaultAiProvider() *Provider {
func getDefaultAiProvider() (*Provider, error) {
provider := Provider{Owner: "admin", Category: "AI"}
existed, err := adapter.Engine.Get(&provider)
if err != nil {
panic(err)
return &provider, err
}
if !existed {
return nil
return nil, nil
}
return &provider
return &provider, nil
}
func GetWechatMiniProgramProvider(application *Application) *Provider {
@ -212,16 +202,18 @@ func GetWechatMiniProgramProvider(application *Application) *Provider {
return nil
}
func UpdateProvider(id string, provider *Provider) bool {
func UpdateProvider(id string, provider *Provider) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getProvider(owner, name) == nil {
return false
if p, err := getProvider(owner, name); err != nil {
return false, err
} else if p == nil {
return false, nil
}
if name != provider.Name {
err := providerChangeTrigger(name, provider.Name)
if err != nil {
return false
return false, nil
}
}
@ -238,37 +230,41 @@ func UpdateProvider(id string, provider *Provider) bool {
affected, err := session.Update(provider)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddProvider(provider *Provider) bool {
func AddProvider(provider *Provider) (bool, error) {
provider.Endpoint = util.GetEndPoint(provider.Endpoint)
provider.IntranetEndpoint = util.GetEndPoint(provider.IntranetEndpoint)
affected, err := adapter.Engine.Insert(provider)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteProvider(provider *Provider) bool {
func DeleteProvider(provider *Provider) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{provider.Owner, provider.Name}).Delete(&Provider{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (p *Provider) getPaymentProvider() (pp.PaymentProvider, *Cert, error) {
cert := &Cert{}
if p.Cert != "" {
cert = getCert(p.Owner, p.Cert)
cert, err := getCert(p.Owner, p.Cert)
if err != nil {
return nil, nil, err
}
if cert == nil {
return nil, nil, fmt.Errorf("the cert: %s does not exist", p.Cert)
}
@ -309,7 +305,11 @@ func GetCaptchaProviderByApplication(applicationId, isCurrentProvider, lang stri
if isCurrentProvider == "true" {
return GetCaptchaProviderByOwnerName(applicationId, lang)
}
application := GetApplication(applicationId)
application, err := GetApplication(applicationId)
if err != nil {
return nil, err
}
if application == nil || len(application.Providers) == 0 {
return nil, fmt.Errorf(i18n.Translate(lang, "provider:Invalid application id"))
}

45
object/record.go
View File

@ -26,11 +26,7 @@ import (
var logPostOnly bool
func init() {
var err error
logPostOnly, err = conf.GetConfigBool("logPostOnly")
if err != nil {
// panic(err)
}
logPostOnly = conf.GetConfigBool("logPostOnly")
}
type Record struct {
@ -108,49 +104,48 @@ func AddRecord(record *Record) bool {
return affected != 0
}
func GetRecordCount(field, value string, filterRecord *Record) int {
func GetRecordCount(field, value string, filterRecord *Record) (int64, error) {
session := GetSession("", -1, -1, field, value, "", "")
count, err := session.Count(filterRecord)
if err != nil {
panic(err)
}
return int(count)
return session.Count(filterRecord)
}
func GetRecords() []*Record {
func GetRecords() ([]*Record, error) {
records := []*Record{}
err := adapter.Engine.Desc("id").Find(&records)
if err != nil {
panic(err)
return records, err
}
return records
return records, nil
}
func GetPaginationRecords(offset, limit int, field, value, sortField, sortOrder string, filterRecord *Record) []*Record {
func GetPaginationRecords(offset, limit int, field, value, sortField, sortOrder string, filterRecord *Record) ([]*Record, error) {
records := []*Record{}
session := GetSession("", offset, limit, field, value, sortField, sortOrder)
err := session.Find(&records, filterRecord)
if err != nil {
panic(err)
return records, err
}
return records
return records, nil
}
func GetRecordsByField(record *Record) []*Record {
func GetRecordsByField(record *Record) ([]*Record, error) {
records := []*Record{}
err := adapter.Engine.Find(&records, record)
if err != nil {
panic(err)
return records, err
}
return records
return records, nil
}
func SendWebhooks(record *Record) error {
webhooks := getWebhooksByOrganization(record.Organization)
webhooks, err := getWebhooksByOrganization(record.Organization)
if err != nil {
return err
}
for _, webhook := range webhooks {
if !webhook.IsEnabled {
continue
@ -166,7 +161,11 @@ func SendWebhooks(record *Record) error {
if matched {
if webhook.IsUserExtended {
user := GetMaskedUser(getUser(record.Organization, record.User))
user, err := GetMaskedUser(getUser(record.Organization, record.User))
if err != nil {
return err
}
record.ExtendedUser = user
}

61
object/resource.go
View File

@ -39,17 +39,12 @@ type Resource struct {
Description string `xorm:"varchar(255)" json:"description"`
}
func GetResourceCount(owner, user, field, value string) int {
func GetResourceCount(owner, user, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Resource{User: user})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Resource{User: user})
}
func GetResources(owner string, user string) []*Resource {
func GetResources(owner string, user string) ([]*Resource, error) {
if owner == "built-in" {
owner = ""
user = ""
@ -58,13 +53,13 @@ func GetResources(owner string, user string) []*Resource {
resources := []*Resource{}
err := adapter.Engine.Desc("created_time").Find(&resources, &Resource{Owner: owner, User: user})
if err != nil {
panic(err)
return resources, err
}
return resources
return resources, err
}
func GetPaginationResources(owner, user string, offset, limit int, field, value, sortField, sortOrder string) []*Resource {
func GetPaginationResources(owner, user string, offset, limit int, field, value, sortField, sortOrder string) ([]*Resource, error) {
if owner == "built-in" {
owner = ""
user = ""
@ -74,70 +69,74 @@ func GetPaginationResources(owner, user string, offset, limit int, field, value,
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&resources, &Resource{User: user})
if err != nil {
panic(err)
return resources, err
}
return resources
return resources, nil
}
func getResource(owner string, name string) *Resource {
func getResource(owner string, name string) (*Resource, error) {
resource := Resource{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&resource)
if err != nil {
panic(err)
return &resource, err
}
if existed {
return &resource
return &resource, nil
}
return nil
return nil, nil
}
func GetResource(id string) *Resource {
func GetResource(id string) (*Resource, error) {
owner, name := util.GetOwnerAndNameFromIdNoCheck(id)
return getResource(owner, name)
}
func UpdateResource(id string, resource *Resource) bool {
func UpdateResource(id string, resource *Resource) (bool, error) {
owner, name := util.GetOwnerAndNameFromIdNoCheck(id)
if getResource(owner, name) == nil {
return false
if r, err := getResource(owner, name); err != nil {
return false, err
} else if r == nil {
return false, nil
}
_, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(resource)
if err != nil {
panic(err)
return false, err
}
// return affected != 0
return true
return true, nil
}
func AddResource(resource *Resource) bool {
func AddResource(resource *Resource) (bool, error) {
affected, err := adapter.Engine.Insert(resource)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteResource(resource *Resource) bool {
func DeleteResource(resource *Resource) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{resource.Owner, resource.Name}).Delete(&Resource{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (resource *Resource) GetId() string {
return fmt.Sprintf("%s/%s", resource.Owner, resource.Name)
}
func AddOrUpdateResource(resource *Resource) bool {
if getResource(resource.Owner, resource.Name) == nil {
func AddOrUpdateResource(resource *Resource) (bool, error) {
if r, err := getResource(resource.Owner, resource.Name); err != nil {
return false, err
} else if r == nil {
return AddResource(resource)
} else {
return UpdateResource(resource.GetId(), resource)

131
object/role.go
View File

@ -36,79 +36,90 @@ type Role struct {
IsEnabled bool `json:"isEnabled"`
}
func GetRoleCount(owner, field, value string) int {
func GetRoleCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Role{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Role{})
}
func GetRoles(owner string) []*Role {
func GetRoles(owner string) ([]*Role, error) {
roles := []*Role{}
err := adapter.Engine.Desc("created_time").Find(&roles, &Role{Owner: owner})
if err != nil {
panic(err)
return roles, err
}
return roles
return roles, nil
}
func GetPaginationRoles(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Role {
func GetPaginationRoles(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Role, error) {
roles := []*Role{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&roles)
if err != nil {
panic(err)
return roles, err
}
return roles
return roles, nil
}
func getRole(owner string, name string) *Role {
func getRole(owner string, name string) (*Role, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
role := Role{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&role)
if err != nil {
panic(err)
return &role, err
}
if existed {
return &role
return &role, nil
} else {
return nil
return nil, nil
}
}
func GetRole(id string) *Role {
func GetRole(id string) (*Role, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getRole(owner, name)
}
func UpdateRole(id string, role *Role) bool {
func UpdateRole(id string, role *Role) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
oldRole := getRole(owner, name)
oldRole, err := getRole(owner, name)
if err != nil {
return false, err
}
if oldRole == nil {
return false
return false, nil
}
visited := map[string]struct{}{}
permissions := GetPermissionsByRole(id)
permissions, err := GetPermissionsByRole(id)
if err != nil {
return false, err
}
for _, permission := range permissions {
removeGroupingPolicies(permission)
removePolicies(permission)
visited[permission.GetId()] = struct{}{}
}
ancestorRoles := GetAncestorRoles(id)
ancestorRoles, err := GetAncestorRoles(id)
if err != nil {
return false, err
}
for _, r := range ancestorRoles {
permissions := GetPermissionsByRole(r.GetId())
permissions, err := GetPermissionsByRole(r.GetId())
if err != nil {
return false, err
}
for _, permission := range permissions {
permissionId := permission.GetId()
if _, ok := visited[permissionId]; !ok {
@ -121,27 +132,38 @@ func UpdateRole(id string, role *Role) bool {
if name != role.Name {
err := roleChangeTrigger(name, role.Name)
if err != nil {
return false
return false, nil
}
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(role)
if err != nil {
panic(err)
return false, err
}
visited = map[string]struct{}{}
newRoleID := role.GetId()
permissions = GetPermissionsByRole(newRoleID)
permissions, err = GetPermissionsByRole(newRoleID)
if err != nil {
return false, err
}
for _, permission := range permissions {
addGroupingPolicies(permission)
addPolicies(permission)
visited[permission.GetId()] = struct{}{}
}
ancestorRoles = GetAncestorRoles(newRoleID)
ancestorRoles, err = GetAncestorRoles(newRoleID)
if err != nil {
return false, err
}
for _, r := range ancestorRoles {
permissions := GetPermissionsByRole(r.GetId())
permissions, err := GetPermissionsByRole(r.GetId())
if err != nil {
return false, err
}
for _, permission := range permissions {
permissionId := permission.GetId()
if _, ok := visited[permissionId]; !ok {
@ -151,16 +173,16 @@ func UpdateRole(id string, role *Role) bool {
}
}
return affected != 0
return affected != 0, nil
}
func AddRole(role *Role) bool {
func AddRole(role *Role) (bool, error) {
affected, err := adapter.Engine.Insert(role)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddRoles(roles []*Role) bool {
@ -202,38 +224,45 @@ func AddRolesInBatch(roles []*Role) bool {
return affected
}
func DeleteRole(role *Role) bool {
func DeleteRole(role *Role) (bool, error) {
roleId := role.GetId()
permissions := GetPermissionsByRole(roleId)
permissions, err := GetPermissionsByRole(roleId)
if err != nil {
return false, err
}
for _, permission := range permissions {
permission.Roles = util.DeleteVal(permission.Roles, roleId)
UpdatePermission(permission.GetId(), permission)
_, err := UpdatePermission(permission.GetId(), permission)
if err != nil {
return false, err
}
}
affected, err := adapter.Engine.ID(core.PK{role.Owner, role.Name}).Delete(&Role{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (role *Role) GetId() string {
return fmt.Sprintf("%s/%s", role.Owner, role.Name)
}
func GetRolesByUser(userId string) []*Role {
func GetRolesByUser(userId string) ([]*Role, error) {
roles := []*Role{}
err := adapter.Engine.Where("users like ?", "%"+userId+"\"%").Find(&roles)
if err != nil {
panic(err)
return roles, err
}
for i := range roles {
roles[i].Users = nil
}
return roles
return roles, nil
}
func roleChangeTrigger(oldName string, newName string) error {
@ -250,6 +279,7 @@ func roleChangeTrigger(oldName string, newName string) error {
if err != nil {
return err
}
for _, role := range roles {
for j, u := range role.Roles {
owner, name := util.GetOwnerAndNameFromId(u)
@ -268,6 +298,7 @@ func roleChangeTrigger(oldName string, newName string) error {
if err != nil {
return err
}
for _, permission := range permissions {
for j, u := range permission.Roles {
// u = organization/username
@ -293,17 +324,17 @@ func GetMaskedRoles(roles []*Role) []*Role {
return roles
}
func GetRolesByNamePrefix(owner string, prefix string) []*Role {
func GetRolesByNamePrefix(owner string, prefix string) ([]*Role, error) {
roles := []*Role{}
err := adapter.Engine.Where("owner=? and name like ?", owner, prefix+"%").Find(&roles)
if err != nil {
panic(err)
return roles, err
}
return roles
return roles, nil
}
func GetAncestorRoles(roleId string) []*Role {
func GetAncestorRoles(roleId string) ([]*Role, error) {
var (
result []*Role
roleMap = make(map[string]*Role)
@ -312,7 +343,11 @@ func GetAncestorRoles(roleId string) []*Role {
owner, _ := util.GetOwnerAndNameFromIdNoCheck(roleId)
allRoles := GetRoles(owner)
allRoles, err := GetRoles(owner)
if err != nil {
return nil, err
}
for _, r := range allRoles {
roleMap[r.GetId()] = r
}
@ -331,7 +366,7 @@ func GetAncestorRoles(roleId string) []*Role {
}
}
return result
return result, nil
}
// containsRole is a helper function to check if a slice of roles contains a specific roleId

22
object/role_upload.go
View File

@ -18,21 +18,29 @@ import (
"github.com/casdoor/casdoor/xlsx"
)
func getRoleMap(owner string) map[string]*Role {
func getRoleMap(owner string) (map[string]*Role, error) {
m := map[string]*Role{}
roles := GetRoles(owner)
roles, err := GetRoles(owner)
if err != nil {
return nil, err
}
for _, role := range roles {
m[role.GetId()] = role
}
return m
return m, nil
}
func UploadRoles(owner string, fileId string) bool {
func UploadRoles(owner string, fileId string) (bool, error) {
table := xlsx.ReadXlsxFile(fileId)
oldUserMap := getRoleMap(owner)
oldUserMap, err := getRoleMap(owner)
if err != nil {
return false, err
}
newRoles := []*Role{}
for index, line := range table {
if index == 0 || parseLineItem(&line, 0) == "" {
@ -57,7 +65,7 @@ func UploadRoles(owner string, fileId string) bool {
}
if len(newRoles) == 0 {
return false
return false, nil
}
return AddRolesInBatch(newRoles)
return AddRolesInBatch(newRoles), nil
}

18
object/saml_idp.go
View File

@ -105,7 +105,11 @@ func NewSamlResponse(user *User, host string, certificate string, destination st
roles := attributes.CreateElement("saml:Attribute")
roles.CreateAttr("Name", "Roles")
roles.CreateAttr("NameFormat", "urn:oasis:names:tc:SAML:2.0:attrname-format:basic")
ExtendUserWithRolesAndPermissions(user)
err := ExtendUserWithRolesAndPermissions(user)
if err != nil {
return nil, err
}
for _, role := range user.Roles {
roles.CreateElement("saml:AttributeValue").CreateAttr("xsi:type", "xs:string").Element().SetText(role.Name)
}
@ -186,7 +190,11 @@ type Attribute struct {
}
func GetSamlMeta(application *Application, host string) (*IdpEntityDescriptor, error) {
cert := getCertByApplication(application)
cert, err := getCertByApplication(application)
if err != nil {
return nil, err
}
block, _ := pem.Decode([]byte(cert.Certificate))
certificate := base64.StdEncoding.EncodeToString(block.Bytes)
@ -263,7 +271,11 @@ func GetSamlResponse(application *Application, user *User, samlRequest string, h
}
// get certificate string
cert := getCertByApplication(application)
cert, err := getCertByApplication(application)
if err != nil {
return "", "", "", err
}
block, _ := pem.Decode([]byte(cert.Certificate))
certificate := base64.StdEncoding.EncodeToString(block.Bytes)

32
object/saml_sp.go
View File

@ -43,7 +43,10 @@ func ParseSamlResponse(samlResponse string, provider *Provider, host string) (st
}
func GenerateSamlRequest(id, relayState, host, lang string) (auth string, method string, err error) {
provider := GetProvider(id)
provider, err := GetProvider(id)
if err != nil {
return "", "", err
}
if provider.Category != "SAML" {
return "", "", fmt.Errorf(i18n.Translate(lang, "saml_sp:provider %s's category is not SAML"), provider.Name)
}
@ -92,27 +95,33 @@ func buildSp(provider *Provider, samlResponse string, host string) (*saml2.SAMLS
}
if provider.EnableSignAuthnRequest {
sp.SignAuthnRequests = true
sp.SPKeyStore = buildSpKeyStore()
sp.SPKeyStore, err = buildSpKeyStore()
if err != nil {
return nil, err
}
}
return sp, nil
}
func buildSpKeyStore() dsig.X509KeyStore {
func buildSpKeyStore() (dsig.X509KeyStore, error) {
keyPair, err := tls.LoadX509KeyPair("object/token_jwt_key.pem", "object/token_jwt_key.key")
if err != nil {
panic(err)
return nil, err
}
return &dsig.TLSCertKeyStore{
PrivateKey: keyPair.PrivateKey,
Certificate: keyPair.Certificate,
}
}, nil
}
func buildSpCertificateStore(provider *Provider, samlResponse string) (dsig.MemoryX509CertificateStore, error) {
func buildSpCertificateStore(provider *Provider, samlResponse string) (certStore dsig.MemoryX509CertificateStore, err error) {
certEncodedData := ""
if samlResponse != "" {
certEncodedData = getCertificateFromSamlResponse(samlResponse, provider.Type)
certEncodedData, err = getCertificateFromSamlResponse(samlResponse, provider.Type)
if err != nil {
return
}
} else if provider.IdP != "" {
certEncodedData = provider.IdP
}
@ -126,17 +135,18 @@ func buildSpCertificateStore(provider *Provider, samlResponse string) (dsig.Memo
return dsig.MemoryX509CertificateStore{}, err
}
certStore := dsig.MemoryX509CertificateStore{
certStore = dsig.MemoryX509CertificateStore{
Roots: []*x509.Certificate{idpCert},
}
return certStore, nil
}
func getCertificateFromSamlResponse(samlResponse string, providerType string) string {
func getCertificateFromSamlResponse(samlResponse string, providerType string) (string, error) {
de, err := base64.StdEncoding.DecodeString(samlResponse)
if err != nil {
panic(err)
return "", err
}
deStr := strings.Replace(string(de), "\n", "", -1)
tagMap := map[string]string{
"Aliyun IDaaS": "ds",
@ -145,5 +155,5 @@ func getCertificateFromSamlResponse(samlResponse string, providerType string) st
tag := tagMap[providerType]
expression := fmt.Sprintf("<%s:X509Certificate>([\\s\\S]*?)</%s:X509Certificate>", tag, tag)
res := regexp.MustCompile(expression).FindStringSubmatch(deStr)
return res[1]
return res[1], nil
}

90
object/session.go
View File

@ -36,7 +36,7 @@ type Session struct {
SessionId []string `json:"sessionId"`
}
func GetSessions(owner string) []*Session {
func GetSessions(owner string) ([]*Session, error) {
sessions := []*Session{}
var err error
if owner != "" {
@ -45,61 +45,58 @@ func GetSessions(owner string) []*Session {
err = adapter.Engine.Desc("created_time").Find(&sessions)
}
if err != nil {
panic(err)
return sessions, err
}
return sessions
return sessions, nil
}
func GetPaginationSessions(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Session {
func GetPaginationSessions(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Session, error) {
sessions := []*Session{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&sessions)
if err != nil {
panic(err)
return sessions, err
}
return sessions
return sessions, nil
}
func GetSessionCount(owner, field, value string) int {
func GetSessionCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Session{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Session{})
}
func GetSingleSession(id string) *Session {
func GetSingleSession(id string) (*Session, error) {
owner, name, application := util.GetOwnerAndNameAndOtherFromId(id)
session := Session{Owner: owner, Name: name, Application: application}
get, err := adapter.Engine.Get(&session)
if err != nil {
panic(err)
return &session, err
}
if !get {
return nil
return nil, nil
}
return &session
return &session, nil
}
func UpdateSession(id string, session *Session) bool {
func UpdateSession(id string, session *Session) (bool, error) {
owner, name, application := util.GetOwnerAndNameAndOtherFromId(id)
if GetSingleSession(id) == nil {
return false
if ss, err := GetSingleSession(id); err != nil {
return false, err
} else if ss == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name, application}).Update(session)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func removeExtraSessionIds(session *Session) {
@ -108,17 +105,21 @@ func removeExtraSessionIds(session *Session) {
}
}
func AddSession(session *Session) bool {
dbSession := GetSingleSession(session.GetId())
func AddSession(session *Session) (bool, error) {
dbSession, err := GetSingleSession(session.GetId())
if err != nil {
return false, err
}
if dbSession == nil {
session.CreatedTime = util.GetCurrentTime()
affected, err := adapter.Engine.Insert(session)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
} else {
m := make(map[string]struct{})
for _, v := range dbSession.SessionId {
@ -136,10 +137,14 @@ func AddSession(session *Session) bool {
}
}
func DeleteSession(id string) bool {
func DeleteSession(id string) (bool, error) {
owner, name, application := util.GetOwnerAndNameAndOtherFromId(id)
if owner == CasdoorOrganization && application == CasdoorApplication {
session := GetSingleSession(id)
session, err := GetSingleSession(id)
if err != nil {
return false, err
}
if session != nil {
DeleteBeegoSession(session.SessionId)
}
@ -147,16 +152,19 @@ func DeleteSession(id string) bool {
affected, err := adapter.Engine.ID(core.PK{owner, name, application}).Delete(&Session{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteSessionId(id string, sessionId string) bool {
session := GetSingleSession(id)
func DeleteSessionId(id string, sessionId string) (bool, error) {
session, err := GetSingleSession(id)
if err != nil {
return false, err
}
if session == nil {
return false
return false, nil
}
owner, _, application := util.GetOwnerAndNameAndOtherFromId(id)
@ -185,17 +193,21 @@ func (session *Session) GetId() string {
return fmt.Sprintf("%s/%s/%s", session.Owner, session.Name, session.Application)
}
func IsSessionDuplicated(id string, sessionId string) bool {
session := GetSingleSession(id)
func IsSessionDuplicated(id string, sessionId string) (bool, error) {
session, err := GetSingleSession(id)
if err != nil {
return false, err
}
if session == nil {
return false
return false, nil
} else {
if len(session.SessionId) > 1 {
return true
return true, nil
} else if len(session.SessionId) < 1 {
return false
return false, nil
} else {
return session.SessionId[0] != sessionId
return session.SessionId[0] != sessionId, nil
}
}
}

6
object/storage.go
View File

@ -30,11 +30,7 @@ import (
var isCloudIntranet bool
func init() {
var err error
isCloudIntranet, err = conf.GetConfigBool("isCloudIntranet")
if err != nil {
// panic(err)
}
isCloudIntranet = conf.GetConfigBool("isCloudIntranet")
}
func getProviderEndpoint(provider *Provider) string {

57
object/subscription.go
View File

@ -63,90 +63,87 @@ func NewSubscription(owner string, user string, plan string, duration int) *Subs
}
}
func GetSubscriptionCount(owner, field, value string) int {
func GetSubscriptionCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Subscription{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Subscription{})
}
func GetSubscriptions(owner string) []*Subscription {
func GetSubscriptions(owner string) ([]*Subscription, error) {
subscriptions := []*Subscription{}
err := adapter.Engine.Desc("created_time").Find(&subscriptions, &Subscription{Owner: owner})
if err != nil {
panic(err)
return subscriptions, err
}
return subscriptions
return subscriptions, nil
}
func GetPaginationSubscriptions(owner string, offset, limit int, field, value, sortField, sortOrder string) []*Subscription {
func GetPaginationSubscriptions(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*Subscription, error) {
subscriptions := []*Subscription{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&subscriptions)
if err != nil {
panic(err)
return subscriptions, err
}
return subscriptions
return subscriptions, nil
}
func getSubscription(owner string, name string) *Subscription {
func getSubscription(owner string, name string) (*Subscription, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
subscription := Subscription{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&subscription)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &subscription
return &subscription, nil
} else {
return nil
return nil, nil
}
}
func GetSubscription(id string) *Subscription {
func GetSubscription(id string) (*Subscription, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getSubscription(owner, name)
}
func UpdateSubscription(id string, subscription *Subscription) bool {
func UpdateSubscription(id string, subscription *Subscription) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getSubscription(owner, name) == nil {
return false
if s, err := getSubscription(owner, name); err != nil {
return false, err
} else if s == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(subscription)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddSubscription(subscription *Subscription) bool {
func AddSubscription(subscription *Subscription) (bool, error) {
affected, err := adapter.Engine.Insert(subscription)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteSubscription(subscription *Subscription) bool {
func DeleteSubscription(subscription *Subscription) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{subscription.Owner, subscription.Name}).Delete(&Subscription{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (subscription *Subscription) GetId() string {

87
object/syncer.go
View File

@ -55,66 +55,61 @@ type Syncer struct {
Adapter *Adapter `xorm:"-" json:"-"`
}
func GetSyncerCount(owner, organization, field, value string) int {
func GetSyncerCount(owner, organization, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Syncer{Organization: organization})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Syncer{Organization: organization})
}
func GetSyncers(owner string) []*Syncer {
func GetSyncers(owner string) ([]*Syncer, error) {
syncers := []*Syncer{}
err := adapter.Engine.Desc("created_time").Find(&syncers, &Syncer{Owner: owner})
if err != nil {
panic(err)
return syncers, err
}
return syncers
return syncers, nil
}
func GetOrganizationSyncers(owner, organization string) []*Syncer {
func GetOrganizationSyncers(owner, organization string) ([]*Syncer, error) {
syncers := []*Syncer{}
err := adapter.Engine.Desc("created_time").Find(&syncers, &Syncer{Owner: owner, Organization: organization})
if err != nil {
panic(err)
return syncers, err
}
return syncers
return syncers, nil
}
func GetPaginationSyncers(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) []*Syncer {
func GetPaginationSyncers(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) ([]*Syncer, error) {
syncers := []*Syncer{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&syncers, &Syncer{Organization: organization})
if err != nil {
panic(err)
return syncers, err
}
return syncers
return syncers, nil
}
func getSyncer(owner string, name string) *Syncer {
func getSyncer(owner string, name string) (*Syncer, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
syncer := Syncer{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&syncer)
if err != nil {
panic(err)
return &syncer, err
}
if existed {
return &syncer
return &syncer, nil
} else {
return nil
return nil, nil
}
}
func GetSyncer(id string) *Syncer {
func GetSyncer(id string) (*Syncer, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getSyncer(owner, name)
}
@ -137,10 +132,12 @@ func GetMaskedSyncers(syncers []*Syncer) []*Syncer {
return syncers
}
func UpdateSyncer(id string, syncer *Syncer) bool {
func UpdateSyncer(id string, syncer *Syncer) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getSyncer(owner, name) == nil {
return false
if s, err := getSyncer(owner, name); err != nil {
return false, err
} else if s == nil {
return false, nil
}
session := adapter.Engine.ID(core.PK{owner, name}).AllCols()
@ -149,56 +146,66 @@ func UpdateSyncer(id string, syncer *Syncer) bool {
}
affected, err := session.Update(syncer)
if err != nil {
panic(err)
return false, err
}
if affected == 1 {
addSyncerJob(syncer)
err = addSyncerJob(syncer)
if err != nil {
return false, err
}
}
return affected != 0
return affected != 0, nil
}
func updateSyncerErrorText(syncer *Syncer, line string) bool {
s := getSyncer(syncer.Owner, syncer.Name)
func updateSyncerErrorText(syncer *Syncer, line string) (bool, error) {
s, err := getSyncer(syncer.Owner, syncer.Name)
if err != nil {
return false, err
}
if s == nil {
return false
return false, nil
}
s.ErrorText = s.ErrorText + line
affected, err := adapter.Engine.ID(core.PK{s.Owner, s.Name}).Cols("error_text").Update(s)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddSyncer(syncer *Syncer) bool {
func AddSyncer(syncer *Syncer) (bool, error) {
affected, err := adapter.Engine.Insert(syncer)
if err != nil {
panic(err)
return false, err
}
if affected == 1 {
addSyncerJob(syncer)
err = addSyncerJob(syncer)
if err != nil {
return false, err
}
}
return affected != 0
return affected != 0, nil
}
func DeleteSyncer(syncer *Syncer) bool {
func DeleteSyncer(syncer *Syncer) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{syncer.Owner, syncer.Name}).Delete(&Syncer{})
if err != nil {
panic(err)
return false, err
}
if affected == 1 {
deleteSyncerJob(syncer)
}
return affected != 0
return affected != 0, nil
}
func (syncer *Syncer) GetId() string {

15
object/syncer_affiliation.go
View File

@ -19,22 +19,25 @@ type Affiliation struct {
Name string `xorm:"varchar(128)" json:"name"`
}
func (syncer *Syncer) getAffiliations() []*Affiliation {
func (syncer *Syncer) getAffiliations() ([]*Affiliation, error) {
affiliations := []*Affiliation{}
err := syncer.Adapter.Engine.Table(syncer.AffiliationTable).Asc("id").Find(&affiliations)
if err != nil {
panic(err)
return nil, err
}
return affiliations
return affiliations, nil
}
func (syncer *Syncer) getAffiliationMap() ([]*Affiliation, map[int]string) {
affiliations := syncer.getAffiliations()
func (syncer *Syncer) getAffiliationMap() ([]*Affiliation, map[int]string, error) {
affiliations, err := syncer.getAffiliations()
if err != nil {
return nil, nil, err
}
m := map[int]string{}
for _, affiliation := range affiliations {
m[affiliation.Id] = affiliation.Name
}
return affiliations, m
return affiliations, m, nil
}

7
object/syncer_cron.go
View File

@ -43,11 +43,11 @@ func clearCron(name string) {
}
}
func addSyncerJob(syncer *Syncer) {
func addSyncerJob(syncer *Syncer) error {
deleteSyncerJob(syncer)
if !syncer.IsEnabled {
return
return nil
}
syncer.initAdapter()
@ -58,10 +58,11 @@ func addSyncerJob(syncer *Syncer) {
cron := getCronMap(syncer.Name)
_, err := cron.AddFunc(schedule, syncer.syncUsers)
if err != nil {
panic(err)
return err
}
cron.Start()
return nil
}
func deleteSyncerJob(syncer *Syncer) {

70
object/syncer_public_api.go
View File

@ -16,46 +16,74 @@ package object
import "fmt"
func getDbSyncerForUser(user *User) *Syncer {
syncers := GetSyncers("admin")
func getDbSyncerForUser(user *User) (*Syncer, error) {
syncers, err := GetSyncers("admin")
if err != nil {
return nil, err
}
for _, syncer := range syncers {
if syncer.Organization == user.Owner && syncer.IsEnabled && syncer.Type == "Database" {
return syncer
return syncer, nil
}
}
return nil
return nil, nil
}
func getEnabledSyncerForOrganization(organization string) *Syncer {
syncers := GetSyncers("admin")
func getEnabledSyncerForOrganization(organization string) (*Syncer, error) {
syncers, err := GetSyncers("admin")
if err != nil {
return nil, err
}
for _, syncer := range syncers {
if syncer.Organization == organization && syncer.IsEnabled {
return syncer
return syncer, nil
}
}
return nil
return nil, nil
}
func AddUserToOriginalDatabase(user *User) {
syncer := getEnabledSyncerForOrganization(user.Owner)
func AddUserToOriginalDatabase(user *User) error {
syncer, err := getEnabledSyncerForOrganization(user.Owner)
if err != nil {
return err
}
if syncer == nil {
return
return nil
}
updatedOUser := syncer.createOriginalUserFromUser(user)
syncer.addUser(updatedOUser)
fmt.Printf("Add from user to oUser: %v\n", updatedOUser)
}
func UpdateUserToOriginalDatabase(user *User) {
syncer := getEnabledSyncerForOrganization(user.Owner)
if syncer == nil {
return
_, err = syncer.addUser(updatedOUser)
if err != nil {
return err
}
newUser := GetUser(user.GetId())
fmt.Printf("Add from user to oUser: %v\n", updatedOUser)
return nil
}
func UpdateUserToOriginalDatabase(user *User) error {
syncer, err := getEnabledSyncerForOrganization(user.Owner)
if err != nil {
return err
}
if syncer == nil {
return nil
}
newUser, err := GetUser(user.GetId())
if err != nil {
return err
}
updatedOUser := syncer.createOriginalUserFromUser(newUser)
syncer.updateUser(updatedOUser)
_, err = syncer.updateUser(updatedOUser)
if err != nil {
return err
}
fmt.Printf("Update from user to oUser: %v\n", updatedOUser)
return nil
}

12
object/syncer_sync.go
View File

@ -37,7 +37,7 @@ func (syncer *Syncer) syncUsers() {
var affiliationMap map[int]string
if syncer.AffiliationTable != "" {
_, affiliationMap = syncer.getAffiliationMap()
_, affiliationMap, err = syncer.getAffiliationMap()
}
newUsers := []*User{}
@ -86,13 +86,19 @@ func (syncer *Syncer) syncUsers() {
}
}
}
AddUsersInBatch(newUsers)
_, err = AddUsersInBatch(newUsers)
if err != nil {
panic(err)
}
for _, user := range users {
id := user.Id
if _, ok := oUserMap[id]; !ok {
newOUser := syncer.createOriginalUserFromUser(user)
syncer.addUser(newOUser)
_, err = syncer.addUser(newOUser)
if err != nil {
panic(err)
}
fmt.Printf("New oUser: %v\n", newOUser)
}
}

18
object/syncer_user.go
View File

@ -122,14 +122,18 @@ func (syncer *Syncer) updateUser(user *OriginalUser) (bool, error) {
}
func (syncer *Syncer) updateUserForOriginalFields(user *User) (bool, error) {
var err error
owner, name := util.GetOwnerAndNameFromId(user.GetId())
oldUser := getUserById(owner, name)
if oldUser == nil {
return false, nil
oldUser, err := getUserById(owner, name)
if oldUser == nil || err != nil {
return false, err
}
if user.Avatar != oldUser.Avatar && user.Avatar != "" {
user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, true)
user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, true)
if err != nil {
return false, err
}
}
columns := syncer.getCasdoorColumns()
@ -175,7 +179,11 @@ func (syncer *Syncer) initAdapter() {
}
func RunSyncUsersJob() {
syncers := GetSyncers("admin")
syncers, err := GetSyncers("admin")
if err != nil {
panic(err)
}
for _, syncer := range syncers {
addSyncerJob(syncer)
}

2
object/syncer_user_test.go
View File

@ -23,7 +23,7 @@ import (
func TestGetUsers(t *testing.T) {
InitConfig()
syncers := GetSyncers("admin")
syncers, _ := GetSyncers("admin")
syncer := syncers[0]
syncer.initAdapter()
users, _ := syncer.getOriginalUsers()

6
object/syner_db_user.go
View File

@ -15,7 +15,11 @@
package object
func (syncer *Syncer) getUsers() []*User {
users := GetUsers(syncer.Organization)
users, err := GetUsers(syncer.Organization)
if err != nil {
panic(err)
}
return users
}

377
object/token.go
View File

@ -91,67 +91,54 @@ type IntrospectionResponse struct {
Jti string `json:"jti,omitempty"`
}
func GetTokenCount(owner, organization, field, value string) int {
func GetTokenCount(owner, organization, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Token{Organization: organization})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Token{Organization: organization})
}
func GetTokens(owner string, organization string) []*Token {
func GetTokens(owner string, organization string) ([]*Token, error) {
tokens := []*Token{}
err := adapter.Engine.Desc("created_time").Find(&tokens, &Token{Owner: owner, Organization: organization})
if err != nil {
panic(err)
}
return tokens
return tokens, err
}
func GetPaginationTokens(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) []*Token {
func GetPaginationTokens(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) ([]*Token, error) {
tokens := []*Token{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&tokens, &Token{Organization: organization})
if err != nil {
panic(err)
}
return tokens
return tokens, err
}
func getToken(owner string, name string) *Token {
func getToken(owner string, name string) (*Token, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
token := Token{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&token)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &token
return &token, nil
}
return nil
return nil, nil
}
func getTokenByCode(code string) *Token {
func getTokenByCode(code string) (*Token, error) {
token := Token{Code: code}
existed, err := adapter.Engine.Get(&token)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &token
return &token, nil
}
return nil
return nil, nil
}
func updateUsedByCode(token *Token) bool {
@ -163,7 +150,7 @@ func updateUsedByCode(token *Token) bool {
return affected != 0
}
func GetToken(id string) *Token {
func GetToken(id string) (*Token, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getToken(owner, name)
}
@ -172,124 +159,155 @@ func (token *Token) GetId() string {
return fmt.Sprintf("%s/%s", token.Owner, token.Name)
}
func UpdateToken(id string, token *Token) bool {
func UpdateToken(id string, token *Token) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getToken(owner, name) == nil {
return false
if t, err := getToken(owner, name); err != nil {
return false, err
} else if t == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(token)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddToken(token *Token) bool {
func AddToken(token *Token) (bool, error) {
affected, err := adapter.Engine.Insert(token)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteToken(token *Token) bool {
func DeleteToken(token *Token) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{token.Owner, token.Name}).Delete(&Token{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func ExpireTokenByAccessToken(accessToken string) (bool, *Application, *Token) {
func ExpireTokenByAccessToken(accessToken string) (bool, *Application, *Token, error) {
token := Token{AccessToken: accessToken}
existed, err := adapter.Engine.Get(&token)
if err != nil {
panic(err)
return false, nil, nil, err
}
if !existed {
return false, nil, nil
return false, nil, nil, nil
}
token.ExpiresIn = 0
affected, err := adapter.Engine.ID(core.PK{token.Owner, token.Name}).Cols("expires_in").Update(&token)
if err != nil {
panic(err)
return false, nil, nil, err
}
application := getApplication(token.Owner, token.Application)
return affected != 0, application, &token
application, err := getApplication(token.Owner, token.Application)
if err != nil {
return false, nil, nil, err
}
return affected != 0, application, &token, nil
}
func GetTokenByAccessToken(accessToken string) *Token {
func GetTokenByAccessToken(accessToken string) (*Token, error) {
// Check if the accessToken is in the database
token := Token{AccessToken: accessToken}
existed, err := adapter.Engine.Get(&token)
if err != nil || !existed {
return nil
if err != nil {
return nil, err
}
return &token
if !existed {
return nil, nil
}
return &token, nil
}
func GetTokenByTokenAndApplication(token string, application string) *Token {
func GetTokenByTokenAndApplication(token string, application string) (*Token, error) {
tokenResult := Token{}
existed, err := adapter.Engine.Where("(refresh_token = ? or access_token = ? ) and application = ?", token, token, application).Get(&tokenResult)
if err != nil || !existed {
return nil
if err != nil {
return nil, err
}
return &tokenResult
if !existed {
return nil, nil
}
return &tokenResult, nil
}
func CheckOAuthLogin(clientId string, responseType string, redirectUri string, scope string, state string, lang string) (string, *Application) {
func CheckOAuthLogin(clientId string, responseType string, redirectUri string, scope string, state string, lang string) (string, *Application, error) {
if responseType != "code" && responseType != "token" && responseType != "id_token" {
return fmt.Sprintf(i18n.Translate(lang, "token:Grant_type: %s is not supported in this application"), responseType), nil
return fmt.Sprintf(i18n.Translate(lang, "token:Grant_type: %s is not supported in this application"), responseType), nil, nil
}
application, err := GetApplicationByClientId(clientId)
if err != nil {
return "", nil, err
}
application := GetApplicationByClientId(clientId)
if application == nil {
return i18n.Translate(lang, "token:Invalid client_id"), nil
return i18n.Translate(lang, "token:Invalid client_id"), nil, nil
}
if !application.IsRedirectUriValid(redirectUri) {
return fmt.Sprintf(i18n.Translate(lang, "token:Redirect URI: %s doesn't exist in the allowed Redirect URI list"), redirectUri), application
return fmt.Sprintf(i18n.Translate(lang, "token:Redirect URI: %s doesn't exist in the allowed Redirect URI list"), redirectUri), application, nil
}
// Mask application for /api/get-app-login
application.ClientSecret = ""
return "", application
return "", application, nil
}
func GetOAuthCode(userId string, clientId string, responseType string, redirectUri string, scope string, state string, nonce string, challenge string, host string, lang string) *Code {
user := GetUser(userId)
func GetOAuthCode(userId string, clientId string, responseType string, redirectUri string, scope string, state string, nonce string, challenge string, host string, lang string) (*Code, error) {
user, err := GetUser(userId)
if err != nil {
return nil, err
}
if user == nil {
return &Code{
Message: fmt.Sprintf("general:The user: %s doesn't exist", userId),
Code: "",
}
}, nil
}
if user.IsForbidden {
return &Code{
Message: "error: the user is forbidden to sign in, please contact the administrator",
Code: "",
}
}, nil
}
msg, application, err := CheckOAuthLogin(clientId, responseType, redirectUri, scope, state, lang)
if err != nil {
return nil, err
}
msg, application := CheckOAuthLogin(clientId, responseType, redirectUri, scope, state, lang)
if msg != "" {
return &Code{
Message: msg,
Code: "",
}
}, nil
}
ExtendUserWithRolesAndPermissions(user)
err = ExtendUserWithRolesAndPermissions(user)
if err != nil {
return nil, err
}
accessToken, refreshToken, tokenName, err := generateJwtToken(application, user, nonce, scope, host)
if err != nil {
panic(err)
return nil, err
}
if challenge == "null" {
@ -313,21 +331,28 @@ func GetOAuthCode(userId string, clientId string, responseType string, redirectU
CodeIsUsed: false,
CodeExpireIn: time.Now().Add(time.Minute * 5).Unix(),
}
AddToken(token)
_, err = AddToken(token)
if err != nil {
return nil, err
}
return &Code{
Message: "",
Code: token.Code,
}
}, nil
}
func GetOAuthToken(grantType string, clientId string, clientSecret string, code string, verifier string, scope string, username string, password string, host string, refreshToken string, tag string, avatar string, lang string) interface{} {
application := GetApplicationByClientId(clientId)
func GetOAuthToken(grantType string, clientId string, clientSecret string, code string, verifier string, scope string, username string, password string, host string, refreshToken string, tag string, avatar string, lang string) (interface{}, error) {
application, err := GetApplicationByClientId(clientId)
if err != nil {
return nil, err
}
if application == nil {
return &TokenError{
Error: InvalidClient,
ErrorDescription: "client_id is invalid",
}
}, nil
}
// Check if grantType is allowed in the current application
@ -336,32 +361,44 @@ func GetOAuthToken(grantType string, clientId string, clientSecret string, code
return &TokenError{
Error: UnsupportedGrantType,
ErrorDescription: fmt.Sprintf("grant_type: %s is not supported in this application", grantType),
}
}, nil
}
var token *Token
var tokenError *TokenError
switch grantType {
case "authorization_code": // Authorization Code Grant
token, tokenError = GetAuthorizationCodeToken(application, clientSecret, code, verifier)
token, tokenError, err = GetAuthorizationCodeToken(application, clientSecret, code, verifier)
case "password": // Resource Owner Password Credentials Grant
token, tokenError = GetPasswordToken(application, username, password, scope, host)
token, tokenError, err = GetPasswordToken(application, username, password, scope, host)
case "client_credentials": // Client Credentials Grant
token, tokenError = GetClientCredentialsToken(application, clientSecret, scope, host)
token, tokenError, err = GetClientCredentialsToken(application, clientSecret, scope, host)
case "refresh_token":
return RefreshToken(grantType, refreshToken, scope, clientId, clientSecret, host)
refreshToken2, err := RefreshToken(grantType, refreshToken, scope, clientId, clientSecret, host)
if err != nil {
return nil, err
}
return refreshToken2, nil
}
if err != nil {
return nil, err
}
if tag == "wechat_miniprogram" {
// Wechat Mini Program
token, tokenError = GetWechatMiniProgramToken(application, code, host, username, avatar, lang)
token, tokenError, err = GetWechatMiniProgramToken(application, code, host, username, avatar, lang)
if err != nil {
return nil, err
}
}
if tokenError != nil {
return tokenError
return tokenError, nil
}
token.CodeIsUsed = true
go updateUsedByCode(token)
tokenWrapper := &TokenWrapper{
@ -373,29 +410,33 @@ func GetOAuthToken(grantType string, clientId string, clientSecret string, code
Scope: token.Scope,
}
return tokenWrapper
return tokenWrapper, nil
}
func RefreshToken(grantType string, refreshToken string, scope string, clientId string, clientSecret string, host string) interface{} {
func RefreshToken(grantType string, refreshToken string, scope string, clientId string, clientSecret string, host string) (interface{}, error) {
// check parameters
if grantType != "refresh_token" {
return &TokenError{
Error: UnsupportedGrantType,
ErrorDescription: "grant_type should be refresh_token",
}
}, nil
}
application := GetApplicationByClientId(clientId)
application, err := GetApplicationByClientId(clientId)
if err != nil {
return nil, err
}
if application == nil {
return &TokenError{
Error: InvalidClient,
ErrorDescription: "client_id is invalid",
}
}, nil
}
if clientSecret != "" && application.ClientSecret != clientSecret {
return &TokenError{
Error: InvalidClient,
ErrorDescription: "client_secret is invalid",
}
}, nil
}
// check whether the refresh token is valid, and has not expired.
token := Token{RefreshToken: refreshToken}
@ -404,33 +445,44 @@ func RefreshToken(grantType string, refreshToken string, scope string, clientId
return &TokenError{
Error: InvalidGrant,
ErrorDescription: "refresh token is invalid, expired or revoked",
}
}, nil
}
cert, err := getCertByApplication(application)
if err != nil {
return nil, err
}
cert := getCertByApplication(application)
_, err = ParseJwtToken(refreshToken, cert)
if err != nil {
return &TokenError{
Error: InvalidGrant,
ErrorDescription: fmt.Sprintf("parse refresh token error: %s", err.Error()),
}
}, nil
}
// generate a new token
user := getUser(application.Organization, token.User)
user, err := getUser(application.Organization, token.User)
if err != nil {
return nil, err
}
if user.IsForbidden {
return &TokenError{
Error: InvalidGrant,
ErrorDescription: "the user is forbidden to sign in, please contact the administrator",
}
}, nil
}
ExtendUserWithRolesAndPermissions(user)
err = ExtendUserWithRolesAndPermissions(user)
if err != nil {
return nil, err
}
newAccessToken, newRefreshToken, tokenName, err := generateJwtToken(application, user, "", scope, host)
if err != nil {
return &TokenError{
Error: EndpointError,
ErrorDescription: fmt.Sprintf("generate jwt token error: %s", err.Error()),
}
}, nil
}
newToken := &Token{
@ -447,8 +499,15 @@ func RefreshToken(grantType string, refreshToken string, scope string, clientId
Scope: scope,
TokenType: "Bearer",
}
AddToken(newToken)
DeleteToken(&token)
_, err = AddToken(newToken)
if err != nil {
return nil, err
}
_, err = DeleteToken(&token)
if err != nil {
return nil, err
}
tokenWrapper := &TokenWrapper{
AccessToken: newToken.AccessToken,
@ -459,7 +518,7 @@ func RefreshToken(grantType string, refreshToken string, scope string, clientId
Scope: newToken.Scope,
}
return tokenWrapper
return tokenWrapper, nil
}
// PkceChallenge: base64-URL-encoded SHA256 hash of verifier, per rfc 7636
@ -486,34 +545,38 @@ func IsGrantTypeValid(method string, grantTypes []string) bool {
// GetAuthorizationCodeToken
// Authorization code flow
func GetAuthorizationCodeToken(application *Application, clientSecret string, code string, verifier string) (*Token, *TokenError) {
func GetAuthorizationCodeToken(application *Application, clientSecret string, code string, verifier string) (*Token, *TokenError, error) {
if code == "" {
return nil, &TokenError{
Error: InvalidRequest,
ErrorDescription: "authorization code should not be empty",
}
}, nil
}
token, err := getTokenByCode(code)
if err != nil {
return nil, nil, err
}
token := getTokenByCode(code)
if token == nil {
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "authorization code is invalid",
}
}, nil
}
if token.CodeIsUsed {
// anti replay attacks
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "authorization code has been used",
}
}, nil
}
if token.CodeChallenge != "" && pkceChallenge(verifier) != token.CodeChallenge {
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "verifier is invalid",
}
}, nil
}
if application.ClientSecret != clientSecret {
@ -523,13 +586,13 @@ func GetAuthorizationCodeToken(application *Application, clientSecret string, co
return nil, &TokenError{
Error: InvalidClient,
ErrorDescription: "client_secret is invalid",
}
}, nil
} else {
if clientSecret != "" {
return nil, &TokenError{
Error: InvalidClient,
ErrorDescription: "client_secret is invalid",
}
}, nil
}
}
}
@ -538,7 +601,7 @@ func GetAuthorizationCodeToken(application *Application, clientSecret string, co
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "the token is for wrong application (client_id)",
}
}, nil
}
if time.Now().Unix() > token.CodeExpireIn {
@ -546,42 +609,50 @@ func GetAuthorizationCodeToken(application *Application, clientSecret string, co
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "authorization code has expired",
}
}, nil
}
return token, nil
return token, nil, nil
}
// GetPasswordToken
// Resource Owner Password Credentials flow
func GetPasswordToken(application *Application, username string, password string, scope string, host string) (*Token, *TokenError) {
user := getUser(application.Organization, username)
func GetPasswordToken(application *Application, username string, password string, scope string, host string) (*Token, *TokenError, error) {
user, err := getUser(application.Organization, username)
if err != nil {
return nil, nil, err
}
if user == nil {
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "the user does not exist",
}
}, nil
}
msg := CheckPassword(user, password, "en")
if msg != "" {
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "invalid username or password",
}
}, nil
}
if user.IsForbidden {
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "the user is forbidden to sign in, please contact the administrator",
}
}, nil
}
err = ExtendUserWithRolesAndPermissions(user)
if err != nil {
return nil, nil, err
}
ExtendUserWithRolesAndPermissions(user)
accessToken, refreshToken, tokenName, err := generateJwtToken(application, user, "", scope, host)
if err != nil {
return nil, &TokenError{
Error: EndpointError,
ErrorDescription: fmt.Sprintf("generate jwt token error: %s", err.Error()),
}
}, nil
}
token := &Token{
Owner: application.Owner,
@ -598,18 +669,22 @@ func GetPasswordToken(application *Application, username string, password string
TokenType: "Bearer",
CodeIsUsed: true,
}
AddToken(token)
return token, nil
_, err = AddToken(token)
if err != nil {
return nil, nil, err
}
return token, nil, nil
}
// GetClientCredentialsToken
// Client Credentials flow
func GetClientCredentialsToken(application *Application, clientSecret string, scope string, host string) (*Token, *TokenError) {
func GetClientCredentialsToken(application *Application, clientSecret string, scope string, host string) (*Token, *TokenError, error) {
if application.ClientSecret != clientSecret {
return nil, &TokenError{
Error: InvalidClient,
ErrorDescription: "client_secret is invalid",
}
}, nil
}
nullUser := &User{
Owner: application.Owner,
@ -623,7 +698,7 @@ func GetClientCredentialsToken(application *Application, clientSecret string, sc
return nil, &TokenError{
Error: EndpointError,
ErrorDescription: fmt.Sprintf("generate jwt token error: %s", err.Error()),
}
}, nil
}
token := &Token{
Owner: application.Owner,
@ -639,18 +714,27 @@ func GetClientCredentialsToken(application *Application, clientSecret string, sc
TokenType: "Bearer",
CodeIsUsed: true,
}
AddToken(token)
return token, nil
_, err = AddToken(token)
if err != nil {
return nil, nil, err
}
return token, nil, nil
}
// GetTokenByUser
// Implicit flow
func GetTokenByUser(application *Application, user *User, scope string, host string) (*Token, error) {
ExtendUserWithRolesAndPermissions(user)
err := ExtendUserWithRolesAndPermissions(user)
if err != nil {
return nil, err
}
accessToken, refreshToken, tokenName, err := generateJwtToken(application, user, "", scope, host)
if err != nil {
return nil, err
}
token := &Token{
Owner: application.Owner,
Name: tokenName,
@ -666,43 +750,56 @@ func GetTokenByUser(application *Application, user *User, scope string, host str
TokenType: "Bearer",
CodeIsUsed: true,
}
AddToken(token)
_, err = AddToken(token)
if err != nil {
return nil, err
}
return token, nil
}
// GetWechatMiniProgramToken
// Wechat Mini Program flow
func GetWechatMiniProgramToken(application *Application, code string, host string, username string, avatar string, lang string) (*Token, *TokenError) {
func GetWechatMiniProgramToken(application *Application, code string, host string, username string, avatar string, lang string) (*Token, *TokenError, error) {
mpProvider := GetWechatMiniProgramProvider(application)
if mpProvider == nil {
return nil, &TokenError{
Error: InvalidClient,
ErrorDescription: "the application does not support wechat mini program",
}
}, nil
}
provider := GetProvider(util.GetId("admin", mpProvider.Name))
provider, err := GetProvider(util.GetId("admin", mpProvider.Name))
if err != nil {
return nil, nil, err
}
mpIdp := idp.NewWeChatMiniProgramIdProvider(provider.ClientId, provider.ClientSecret)
session, err := mpIdp.GetSessionByCode(code)
if err != nil {
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: fmt.Sprintf("get wechat mini program session error: %s", err.Error()),
}
}, nil
}
openId, unionId := session.Openid, session.Unionid
if openId == "" && unionId == "" {
return nil, &TokenError{
Error: InvalidRequest,
ErrorDescription: "the wechat mini program session is invalid",
}
}, nil
}
user := getUserByWechatId(openId, unionId)
user, err := getUserByWechatId(openId, unionId)
if err != nil {
return nil, nil, err
}
if user == nil {
if !application.EnableSignUp {
return nil, &TokenError{
Error: InvalidGrant,
ErrorDescription: "the application does not allow to sign up new account",
}
}, nil
}
// Add new user
var name string
@ -730,16 +827,23 @@ func GetWechatMiniProgramToken(application *Application, code string, host strin
UserPropertiesWechatUnionId: unionId,
},
}
AddUser(user)
_, err = AddUser(user)
if err != nil {
return nil, nil, err
}
}
err = ExtendUserWithRolesAndPermissions(user)
if err != nil {
return nil, nil, err
}
ExtendUserWithRolesAndPermissions(user)
accessToken, refreshToken, tokenName, err := generateJwtToken(application, user, "", "", host)
if err != nil {
return nil, &TokenError{
Error: EndpointError,
ErrorDescription: fmt.Sprintf("generate jwt token error: %s", err.Error()),
}
}, nil
}
token := &Token{
@ -757,6 +861,9 @@ func GetWechatMiniProgramToken(application *Application, code string, host strin
TokenType: "Bearer",
CodeIsUsed: true,
}
AddToken(token)
return token, nil
_, err = AddToken(token)
if err != nil {
return nil, nil, err
}
return token, nil, nil
}

23
object/token_cas.go
View File

@ -177,7 +177,9 @@ func StoreCasTokenForProxyTicket(token *CasAuthenticationSuccess, targetService,
}
func GenerateCasToken(userId string, service string) (string, error) {
if user := GetUser(userId); user != nil {
if user, err := GetUser(userId); err != nil {
return "", err
} else if user != nil {
authenticationSuccess := CasAuthenticationSuccess{
User: user.Name,
Attributes: &CasAttributes{
@ -232,18 +234,31 @@ func GetValidationBySaml(samlRequest string, host string) (string, string, error
return "", "", fmt.Errorf("ticket %s found", ticket)
}
user := GetUser(userId)
user, err := GetUser(userId)
if err != nil {
return "", "", err
}
if user == nil {
return "", "", fmt.Errorf("user %s found", userId)
}
application := GetApplicationByUser(user)
application, err := GetApplicationByUser(user)
if err != nil {
return "", "", err
}
if application == nil {
return "", "", fmt.Errorf("application for user %s found", userId)
}
samlResponse := NewSamlResponse11(user, request.RequestID, host)
cert := getCertByApplication(application)
cert, err := getCertByApplication(application)
if err != nil {
return "", "", err
}
block, _ := pem.Decode([]byte(cert.Certificate))
certificate := base64.StdEncoding.EncodeToString(block.Bytes)
randomKeyStore := &X509Key{

12
object/token_jwt.go
View File

@ -273,7 +273,10 @@ func generateJwtToken(application *Application, user *User, nonce string, scope
refreshToken = jwt.NewWithClaims(jwt.SigningMethodRS256, claimsWithoutThirdIdp)
}
cert := getCertByApplication(application)
cert, err := getCertByApplication(application)
if err != nil {
return "", "", "", err
}
// RSA private key
key, err := jwt.ParseRSAPrivateKeyFromPEM([]byte(cert.PrivateKey))
@ -316,5 +319,10 @@ func ParseJwtToken(token string, cert *Cert) (*Claims, error) {
}
func ParseJwtTokenByApplication(token string, application *Application) (*Claims, error) {
return ParseJwtToken(token, getCertByApplication(application))
cert, err := getCertByApplication(application)
if err != nil {
return nil, err
}
return ParseJwtToken(token, cert)
}

326
object/user.go
View File

@ -191,217 +191,206 @@ type ManagedAccount struct {
SigninUrl string `xorm:"varchar(200)" json:"signinUrl"`
}
func GetGlobalUserCount(field, value string) int {
func GetGlobalUserCount(field, value string) (int64, error) {
session := GetSession("", -1, -1, field, value, "", "")
count, err := session.Count(&User{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&User{})
}
func GetGlobalUsers() []*User {
func GetGlobalUsers() ([]*User, error) {
users := []*User{}
err := adapter.Engine.Desc("created_time").Find(&users)
if err != nil {
panic(err)
return nil, err
}
return users
return users, nil
}
func GetPaginationGlobalUsers(offset, limit int, field, value, sortField, sortOrder string) []*User {
func GetPaginationGlobalUsers(offset, limit int, field, value, sortField, sortOrder string) ([]*User, error) {
users := []*User{}
session := GetSession("", offset, limit, field, value, sortField, sortOrder)
err := session.Find(&users)
if err != nil {
panic(err)
return nil, err
}
return users
return users, nil
}
func GetUserCount(owner, field, value string) int {
func GetUserCount(owner, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&User{})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&User{})
}
func GetOnlineUserCount(owner string, isOnline int) int {
count, err := adapter.Engine.Where("is_online = ?", isOnline).Count(&User{Owner: owner})
if err != nil {
panic(err)
}
return int(count)
func GetOnlineUserCount(owner string, isOnline int) (int64, error) {
return adapter.Engine.Where("is_online = ?", isOnline).Count(&User{Owner: owner})
}
func GetUsers(owner string) []*User {
func GetUsers(owner string) ([]*User, error) {
users := []*User{}
err := adapter.Engine.Desc("created_time").Find(&users, &User{Owner: owner})
if err != nil {
panic(err)
return nil, err
}
return users
return users, nil
}
func GetUsersByTag(owner string, tag string) []*User {
func GetUsersByTag(owner string, tag string) ([]*User, error) {
users := []*User{}
err := adapter.Engine.Desc("created_time").Find(&users, &User{Owner: owner, Tag: tag})
if err != nil {
panic(err)
return nil, err
}
return users
return users, nil
}
func GetSortedUsers(owner string, sorter string, limit int) []*User {
func GetSortedUsers(owner string, sorter string, limit int) ([]*User, error) {
users := []*User{}
err := adapter.Engine.Desc(sorter).Limit(limit, 0).Find(&users, &User{Owner: owner})
if err != nil {
panic(err)
return nil, err
}
return users
return users, nil
}
func GetPaginationUsers(owner string, offset, limit int, field, value, sortField, sortOrder string) []*User {
func GetPaginationUsers(owner string, offset, limit int, field, value, sortField, sortOrder string) ([]*User, error) {
users := []*User{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&users)
if err != nil {
panic(err)
return nil, err
}
return users
return users, nil
}
func getUser(owner string, name string) *User {
func getUser(owner string, name string) (*User, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
user := User{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&user)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &user
return &user, nil
} else {
return nil
return nil, nil
}
}
func getUserById(owner string, id string) *User {
func getUserById(owner string, id string) (*User, error) {
if owner == "" || id == "" {
return nil
return nil, nil
}
user := User{Owner: owner, Id: id}
existed, err := adapter.Engine.Get(&user)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &user
return &user, nil
} else {
return nil
return nil, nil
}
}
func getUserByWechatId(wechatOpenId string, wechatUnionId string) *User {
func getUserByWechatId(wechatOpenId string, wechatUnionId string) (*User, error) {
if wechatUnionId == "" {
wechatUnionId = wechatOpenId
}
user := &User{}
existed, err := adapter.Engine.Where("wechat = ? OR wechat = ?", wechatOpenId, wechatUnionId).Get(user)
if err != nil {
panic(err)
return nil, err
}
if existed {
return user
return user, nil
} else {
return nil
return nil, nil
}
}
func GetUserByEmail(owner string, email string) *User {
func GetUserByEmail(owner string, email string) (*User, error) {
if owner == "" || email == "" {
return nil
return nil, nil
}
user := User{Owner: owner, Email: email}
existed, err := adapter.Engine.Get(&user)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &user
return &user, nil
} else {
return nil
return nil, nil
}
}
func GetUserByPhone(owner string, phone string) *User {
func GetUserByPhone(owner string, phone string) (*User, error) {
if owner == "" || phone == "" {
return nil
return nil, nil
}
user := User{Owner: owner, Phone: phone}
existed, err := adapter.Engine.Get(&user)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &user
return &user, nil
} else {
return nil
return nil, nil
}
}
func GetUserByUserId(owner string, userId string) *User {
func GetUserByUserId(owner string, userId string) (*User, error) {
if owner == "" || userId == "" {
return nil
return nil, nil
}
user := User{Owner: owner, Id: userId}
existed, err := adapter.Engine.Get(&user)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &user
return &user, nil
} else {
return nil
return nil, nil
}
}
func GetUser(id string) *User {
func GetUser(id string) (*User, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getUser(owner, name)
}
func GetUserNoCheck(id string) *User {
func GetUserNoCheck(id string) (*User, error) {
owner, name := util.GetOwnerAndNameFromIdNoCheck(id)
return getUser(owner, name)
}
func GetMaskedUser(user *User) *User {
func GetMaskedUser(user *User, errs ...error) (*User, error) {
if len(errs) > 0 && errs[0] != nil {
return nil, errs[0]
}
if user == nil {
return nil
return nil, nil
}
if user.Password != "" {
@ -419,51 +408,69 @@ func GetMaskedUser(user *User) *User {
user.MultiFactorAuths[i] = GetMaskedProps(props)
}
}
return user
return user, nil
}
func GetMaskedUsers(users []*User) []*User {
for _, user := range users {
user = GetMaskedUser(user)
func GetMaskedUsers(users []*User, errs ...error) ([]*User, error) {
if len(errs) > 0 && errs[0] != nil {
return nil, errs[0]
}
return users
var err error
for _, user := range users {
user, err = GetMaskedUser(user)
if err != nil {
return nil, err
}
}
return users, nil
}
func GetLastUser(owner string) *User {
func GetLastUser(owner string) (*User, error) {
user := User{Owner: owner}
existed, err := adapter.Engine.Desc("created_time", "id").Get(&user)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &user
return &user, nil
}
return nil
return nil, nil
}
func UpdateUser(id string, user *User, columns []string, isAdmin bool) bool {
func UpdateUser(id string, user *User, columns []string, isAdmin bool) (bool, error) {
var err error
owner, name := util.GetOwnerAndNameFromIdNoCheck(id)
oldUser := getUser(owner, name)
oldUser, err := getUser(owner, name)
if err != nil {
return false, err
}
if oldUser == nil {
return false
return false, nil
}
if name != user.Name {
err := userChangeTrigger(name, user.Name)
if err != nil {
return false
return false, nil
}
}
if user.Password == "***" {
user.Password = oldUser.Password
}
user.UpdateUserHash()
err = user.UpdateUserHash()
if err != nil {
panic(err)
}
if user.Avatar != oldUser.Avatar && user.Avatar != "" && user.PermanentAvatar != "*" {
user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
if err != nil {
return false, err
}
}
if len(columns) == 0 {
@ -487,77 +494,105 @@ func UpdateUser(id string, user *User, columns []string, isAdmin bool) bool {
affected, err := adapter.Engine.ID(core.PK{owner, name}).Cols(columns...).Update(user)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func UpdateUserForAllFields(id string, user *User) bool {
func UpdateUserForAllFields(id string, user *User) (bool, error) {
var err error
owner, name := util.GetOwnerAndNameFromId(id)
oldUser := getUser(owner, name)
oldUser, err := getUser(owner, name)
if err != nil {
return false, err
}
if oldUser == nil {
return false
return false, nil
}
if name != user.Name {
err := userChangeTrigger(name, user.Name)
if err != nil {
return false
return false, nil
}
}
user.UpdateUserHash()
err = user.UpdateUserHash()
if err != nil {
return false, err
}
if user.Avatar != oldUser.Avatar && user.Avatar != "" {
user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
if err != nil {
return false, err
}
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(user)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddUser(user *User) bool {
func AddUser(user *User) (bool, error) {
var err error
if user.Id == "" {
user.Id = util.GenerateId()
}
if user.Owner == "" || user.Name == "" {
return false
return false, nil
}
organization := GetOrganizationByUser(user)
organization, _ := GetOrganizationByUser(user)
if organization == nil {
return false
return false, nil
}
user.UpdateUserPassword(organization)
user.UpdateUserHash()
user.PreHash = user.Hash
updated := user.refreshAvatar()
if updated && user.PermanentAvatar != "*" {
user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
err = user.UpdateUserHash()
if err != nil {
return false, err
}
user.Ranking = GetUserCount(user.Owner, "", "") + 1
user.PreHash = user.Hash
updated, err := user.refreshAvatar()
if err != nil {
return false, err
}
if updated && user.PermanentAvatar != "*" {
user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, false)
if err != nil {
return false, err
}
}
count, err := GetUserCount(user.Owner, "", "")
if err != nil {
return false, err
}
user.Ranking = int(count + 1)
affected, err := adapter.Engine.Insert(user)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddUsers(users []*User) bool {
func AddUsers(users []*User) (bool, error) {
var err error
if len(users) == 0 {
return false
return false, nil
}
// organization := GetOrganizationByUser(users[0])
@ -565,27 +600,34 @@ func AddUsers(users []*User) bool {
// this function is only used for syncer or batch upload, so no need to encrypt the password
// user.UpdateUserPassword(organization)
user.UpdateUserHash()
err = user.UpdateUserHash()
if err != nil {
return false, err
}
user.PreHash = user.Hash
user.PermanentAvatar = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, true)
user.PermanentAvatar, err = getPermanentAvatarUrl(user.Owner, user.Name, user.Avatar, true)
if err != nil {
return false, err
}
}
affected, err := adapter.Engine.Insert(users)
if err != nil {
if !strings.Contains(err.Error(), "Duplicate entry") {
panic(err)
return false, err
}
}
return affected != 0
return affected != 0, nil
}
func AddUsersInBatch(users []*User) bool {
func AddUsersInBatch(users []*User) (bool, error) {
batchSize := conf.GetConfigBatchSize()
if len(users) == 0 {
return false
return false, nil
}
affected := false
@ -599,24 +641,29 @@ func AddUsersInBatch(users []*User) bool {
tmp := users[start:end]
// TODO: save to log instead of standard output
// fmt.Printf("Add users: [%d - %d].\n", start, end)
if AddUsers(tmp) {
if ok, err := AddUsers(tmp); err != nil {
return false, err
} else if ok {
affected = true
}
}
return affected
return affected, nil
}
func DeleteUser(user *User) bool {
func DeleteUser(user *User) (bool, error) {
// Forced offline the user first
DeleteSession(util.GetSessionId(user.Owner, user.Name, CasdoorApplication))
_, err := DeleteSession(util.GetSessionId(user.Owner, user.Name, CasdoorApplication))
if err != nil {
return false, err
}
affected, err := adapter.Engine.ID(core.PK{user.Owner, user.Name}).Delete(&User{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func GetUserInfo(user *User, scope string, aud string, host string) *Userinfo {
@ -644,7 +691,7 @@ func GetUserInfo(user *User, scope string, aud string, host string) *Userinfo {
return &resp
}
func LinkUserAccount(user *User, field string, value string) bool {
func LinkUserAccount(user *User, field string, value string) (bool, error) {
return SetUserField(user, field, value)
}
@ -656,13 +703,18 @@ func isUserIdGlobalAdmin(userId string) bool {
return strings.HasPrefix(userId, "built-in/")
}
func ExtendUserWithRolesAndPermissions(user *User) {
func ExtendUserWithRolesAndPermissions(user *User) (err error) {
if user == nil {
return
}
user.Roles = GetRolesByUser(user.GetId())
user.Permissions = GetPermissionsByUser(user.GetId())
user.Roles, err = GetRolesByUser(user.GetId())
if err != nil {
return
}
user.Permissions, err = GetPermissionsByUser(user.GetId())
return
}
func userChangeTrigger(oldName string, newName string) error {
@ -679,6 +731,7 @@ func userChangeTrigger(oldName string, newName string) error {
if err != nil {
return err
}
for _, role := range roles {
for j, u := range role.Users {
// u = organization/username
@ -722,7 +775,7 @@ func userChangeTrigger(oldName string, newName string) error {
return session.Commit()
}
func (user *User) refreshAvatar() bool {
func (user *User) refreshAvatar() (bool, error) {
var err error
var fileBuffer *bytes.Buffer
var ext string
@ -732,13 +785,13 @@ func (user *User) refreshAvatar() bool {
client := proxy.ProxyHttpClient
has, err := hasGravatar(client, user.Email)
if err != nil {
panic(err)
return false, err
}
if has {
fileBuffer, ext, err = getGravatarFileBuffer(client, user.Email)
if err != nil {
panic(err)
return false, err
}
}
}
@ -746,17 +799,20 @@ func (user *User) refreshAvatar() bool {
if fileBuffer == nil && strings.Contains(user.Avatar, "Identicon") {
fileBuffer, ext, err = getIdenticonFileBuffer(user.Name)
if err != nil {
panic(err)
return false, err
}
}
if fileBuffer != nil {
avatarUrl := getPermanentAvatarUrlFromBuffer(user.Owner, user.Name, fileBuffer, ext, true)
avatarUrl, err := getPermanentAvatarUrlFromBuffer(user.Owner, user.Name, fileBuffer, ext, true)
if err != nil {
return false, err
}
user.Avatar = avatarUrl
return true
return true, nil
}
return false
return false, nil
}
func (user *User) IsMfaEnabled() bool {

23
object/user_cred.go
View File

@ -16,18 +16,27 @@ package object
import "github.com/casdoor/casdoor/cred"
func calculateHash(user *User) string {
syncer := getDbSyncerForUser(user)
if syncer == nil {
return ""
func calculateHash(user *User) (string, error) {
syncer, err := getDbSyncerForUser(user)
if err != nil {
return "", err
}
return syncer.calculateHash(user)
if syncer == nil {
return "", nil
}
return syncer.calculateHash(user), nil
}
func (user *User) UpdateUserHash() {
hash := calculateHash(user)
func (user *User) UpdateUserHash() error {
hash, err := calculateHash(user)
if err != nil {
return err
}
user.Hash = hash
return nil
}
func (user *User) UpdateUserPassword(organization *Organization) {

17
object/user_test.go
View File

@ -36,7 +36,7 @@ func updateUserColumn(column string, user *User) bool {
func TestSyncAvatarsFromGitHub(t *testing.T) {
InitConfig()
users := GetGlobalUsers()
users, _ := GetGlobalUsers()
for _, user := range users {
if user.GitHub == "" {
continue
@ -50,7 +50,7 @@ func TestSyncAvatarsFromGitHub(t *testing.T) {
func TestSyncIds(t *testing.T) {
InitConfig()
users := GetGlobalUsers()
users, _ := GetGlobalUsers()
for _, user := range users {
if user.Id != "" {
continue
@ -64,13 +64,16 @@ func TestSyncIds(t *testing.T) {
func TestSyncHashes(t *testing.T) {
InitConfig()
users := GetGlobalUsers()
users, _ := GetGlobalUsers()
for _, user := range users {
if user.Hash != "" {
continue
}
user.UpdateUserHash()
err := user.UpdateUserHash()
if err != nil {
panic(err)
}
updateUserColumn("hash", user)
}
}
@ -92,7 +95,7 @@ func TestGetMaskedUsers(t *testing.T) {
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := GetMaskedUsers(tt.args.users); !reflect.DeepEqual(got, tt.want) {
if got, _ := GetMaskedUsers(tt.args.users); !reflect.DeepEqual(got, tt.want) {
t.Errorf("GetMaskedUsers() = %v, want %v", got, tt.want)
}
})
@ -102,7 +105,7 @@ func TestGetMaskedUsers(t *testing.T) {
func TestGetUserByField(t *testing.T) {
InitConfig()
user := GetUserByField("built-in", "DingTalk", "test")
user, _ := GetUserByField("built-in", "DingTalk", "test")
if user != nil {
t.Logf("%+v", user)
} else {
@ -115,7 +118,7 @@ func TestGetEmailsForUsers(t *testing.T) {
emailMap := map[string]int{}
emails := []string{}
users := GetUsers("built-in")
users, _ := GetUsers("built-in")
for _, user := range users {
if user.Email == "" {
continue

19
object/user_upload.go
View File

@ -22,15 +22,18 @@ import (
"github.com/casdoor/casdoor/xlsx"
)
func getUserMap(owner string) map[string]*User {
func getUserMap(owner string) (map[string]*User, error) {
m := map[string]*User{}
users := GetUsers(owner)
users, err := GetUsers(owner)
if err != nil {
return m, err
}
for _, user := range users {
m[user.GetId()] = user
}
return m
return m, nil
}
func parseLineItem(line *[]string, i int) string {
@ -70,10 +73,14 @@ func parseListItem(lines *[]string, i int) []string {
return trimmedItems
}
func UploadUsers(owner string, fileId string) bool {
func UploadUsers(owner string, fileId string) (bool, error) {
table := xlsx.ReadXlsxFile(fileId)
oldUserMap := getUserMap(owner)
oldUserMap, err := getUserMap(owner)
if err != nil {
return false, err
}
newUsers := []*User{}
for index, line := range table {
if index == 0 || parseLineItem(&line, 0) == "" {
@ -135,7 +142,7 @@ func UploadUsers(owner string, fileId string) bool {
}
if len(newUsers) == 0 {
return false
return false, nil
}
return AddUsersInBatch(newUsers)
}

89
object/user_util.go
View File

@ -24,62 +24,70 @@ import (
"github.com/xorm-io/core"
)
func GetUserByField(organizationName string, field string, value string) *User {
func GetUserByField(organizationName string, field string, value string) (*User, error) {
if field == "" || value == "" {
return nil
return nil, nil
}
user := User{Owner: organizationName}
existed, err := adapter.Engine.Where(fmt.Sprintf("%s=?", strings.ToLower(field)), value).Get(&user)
if err != nil {
panic(err)
return nil, err
}
if existed {
return &user
return &user, nil
} else {
return nil
return nil, nil
}
}
func HasUserByField(organizationName string, field string, value string) bool {
return GetUserByField(organizationName, field, value) != nil
user, err := GetUserByField(organizationName, field, value)
if err != nil {
panic(err)
}
return user != nil
}
func GetUserByFields(organization string, field string) *User {
func GetUserByFields(organization string, field string) (*User, error) {
// check username
user := GetUserByField(organization, "name", field)
if user != nil {
return user
user, err := GetUserByField(organization, "name", field)
if err != nil || user != nil {
return user, err
}
// check email
if strings.Contains(field, "@") {
user = GetUserByField(organization, "email", field)
if user != nil {
return user
user, err = GetUserByField(organization, "email", field)
if user != nil || err != nil {
return user, err
}
}
// check phone
user = GetUserByField(organization, "phone", field)
if user != nil {
return user
user, err = GetUserByField(organization, "phone", field)
if user != nil || err != nil {
return user, err
}
// check ID card
user = GetUserByField(organization, "id_card", field)
if user != nil {
return user
user, err = GetUserByField(organization, "id_card", field)
if user != nil || err != nil {
return user, err
}
return nil
return nil, nil
}
func SetUserField(user *User, field string, value string) bool {
func SetUserField(user *User, field string, value string) (bool, error) {
bean := make(map[string]interface{})
if field == "password" {
organization := GetOrganizationByUser(user)
organization, err := GetOrganizationByUser(user)
if err != nil {
return false, err
}
user.UpdateUserPassword(organization)
bean[strings.ToLower(field)] = user.Password
bean["password_type"] = user.PasswordType
@ -89,17 +97,25 @@ func SetUserField(user *User, field string, value string) bool {
affected, err := adapter.Engine.Table(user).ID(core.PK{user.Owner, user.Name}).Update(bean)
if err != nil {
panic(err)
return false, err
}
user, err = getUser(user.Owner, user.Name)
if err != nil {
return false, err
}
err = user.UpdateUserHash()
if err != nil {
return false, err
}
user = getUser(user.Owner, user.Name)
user.UpdateUserHash()
_, err = adapter.Engine.ID(core.PK{user.Owner, user.Name}).Cols("hash").Update(user)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func GetUserField(user *User, field string) string {
@ -121,7 +137,7 @@ func setUserProperty(user *User, field string, value string) {
}
}
func SetUserOAuthProperties(organization *Organization, user *User, providerType string, userInfo *idp.UserInfo) bool {
func SetUserOAuthProperties(organization *Organization, user *User, providerType string, userInfo *idp.UserInfo) (bool, error) {
if userInfo.Id != "" {
propertyName := fmt.Sprintf("oauth_%s_id", providerType)
setUserProperty(user, propertyName, userInfo.Id)
@ -164,11 +180,10 @@ func SetUserOAuthProperties(organization *Organization, user *User, providerType
}
}
affected := UpdateUserForAllFields(user.GetId(), user)
return affected
return UpdateUserForAllFields(user.GetId(), user)
}
func ClearUserOAuthProperties(user *User, providerType string) bool {
func ClearUserOAuthProperties(user *User, providerType string) (bool, error) {
for k := range user.Properties {
prefix := fmt.Sprintf("oauth_%s_", providerType)
if strings.HasPrefix(k, prefix) {
@ -178,14 +193,18 @@ func ClearUserOAuthProperties(user *User, providerType string) bool {
affected, err := adapter.Engine.ID(core.PK{user.Owner, user.Name}).Cols("properties").Update(user)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func CheckPermissionForUpdateUser(oldUser, newUser *User, isAdmin bool, lang string) (bool, string) {
organization := GetOrganizationByUser(oldUser)
organization, err := GetOrganizationByUser(oldUser)
if err != nil {
return false, err.Error()
}
var itemsChanged []*AccountItem
if oldUser.Owner != newUser.Owner {
@ -310,7 +329,7 @@ func (user *User) GetCountryCode(countryCode string) string {
return user.CountryCode
}
if org := GetOrganizationByUser(user); org != nil && len(org.CountryCodes) > 0 {
if org, _ := GetOrganizationByUser(user); org != nil && len(org.CountryCodes) > 0 {
return org.CountryCodes[0]
}
return ""

15
object/user_webauthn.go
View File

@ -16,6 +16,7 @@ package object
import (
"encoding/base64"
"fmt"
"net/url"
"strings"
@ -24,14 +25,14 @@ import (
"github.com/go-webauthn/webauthn/webauthn"
)
func GetWebAuthnObject(host string) *webauthn.WebAuthn {
func GetWebAuthnObject(host string) (*webauthn.WebAuthn, error) {
var err error
_, originBackend := getOriginFromHost(host)
localUrl, err := url.Parse(originBackend)
if err != nil {
panic("error when parsing origin:" + err.Error())
return nil, fmt.Errorf("error when parsing origin:" + err.Error())
}
webAuthn, err := webauthn.New(&webauthn.Config{
@ -41,10 +42,10 @@ func GetWebAuthnObject(host string) *webauthn.WebAuthn {
// RPIcon: "https://duo.com/logo.png", // Optional icon URL for your site
})
if err != nil {
panic(err)
return nil, err
}
return webAuthn
return webAuthn, nil
}
// WebAuthnID
@ -84,17 +85,17 @@ func (user *User) CredentialExcludeList() []protocol.CredentialDescriptor {
return credentialExcludeList
}
func (user *User) AddCredentials(credential webauthn.Credential, isGlobalAdmin bool) bool {
func (user *User) AddCredentials(credential webauthn.Credential, isGlobalAdmin bool) (bool, error) {
user.WebauthnCredentials = append(user.WebauthnCredentials, credential)
return UpdateUser(user.GetId(), user, []string{"webauthnCredentials"}, isGlobalAdmin)
}
func (user *User) DeleteCredentials(credentialIdBase64 string) bool {
func (user *User) DeleteCredentials(credentialIdBase64 string) (bool, error) {
for i, credential := range user.WebauthnCredentials {
if base64.StdEncoding.EncodeToString(credential.ID) == credentialIdBase64 {
user.WebauthnCredentials = append(user.WebauthnCredentials[0:i], user.WebauthnCredentials[i+1:]...)
return UpdateUserForAllFields(user.GetId(), user)
}
}
return false
return false, nil
}

25
object/verification.go
View File

@ -151,21 +151,24 @@ func AddToVerificationRecord(user *User, provider *Provider, remoteAddr, recordT
return nil
}
func getVerificationRecord(dest string) *VerificationRecord {
func getVerificationRecord(dest string) (*VerificationRecord, error) {
var record VerificationRecord
record.Receiver = dest
has, err := adapter.Engine.Desc("time").Where("is_used = false").Get(&record)
if err != nil {
panic(err)
return nil, err
}
if !has {
return nil
return nil, nil
}
return &record
return &record, nil
}
func CheckVerificationCode(dest, code, lang string) *VerifyResult {
record := getVerificationRecord(dest)
record, err := getVerificationRecord(dest)
if err != nil {
panic(err)
}
if record == nil {
return &VerifyResult{noRecordError, i18n.Translate(lang, "verification:Code has not been sent yet!")}
@ -188,17 +191,15 @@ func CheckVerificationCode(dest, code, lang string) *VerifyResult {
return &VerifyResult{VerificationSuccess, ""}
}
func DisableVerificationCode(dest string) {
record := getVerificationRecord(dest)
if record == nil {
func DisableVerificationCode(dest string) (err error) {
record, err := getVerificationRecord(dest)
if record == nil || err != nil {
return
}
record.IsUsed = true
_, err := adapter.Engine.ID(core.PK{record.Owner, record.Name}).AllCols().Update(record)
if err != nil {
panic(err)
}
_, err = adapter.Engine.ID(core.PK{record.Owner, record.Name}).AllCols().Update(record)
return
}
func CheckSigninCode(user *User, dest, code, lang string) string {

63
object/webhook.go
View File

@ -42,100 +42,97 @@ type Webhook struct {
IsEnabled bool `json:"isEnabled"`
}
func GetWebhookCount(owner, organization, field, value string) int {
func GetWebhookCount(owner, organization, field, value string) (int64, error) {
session := GetSession(owner, -1, -1, field, value, "", "")
count, err := session.Count(&Webhook{Organization: organization})
if err != nil {
panic(err)
}
return int(count)
return session.Count(&Webhook{Organization: organization})
}
func GetWebhooks(owner string, organization string) []*Webhook {
func GetWebhooks(owner string, organization string) ([]*Webhook, error) {
webhooks := []*Webhook{}
err := adapter.Engine.Desc("created_time").Find(&webhooks, &Webhook{Owner: owner, Organization: organization})
if err != nil {
panic(err)
return webhooks, err
}
return webhooks
return webhooks, nil
}
func GetPaginationWebhooks(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) []*Webhook {
func GetPaginationWebhooks(owner, organization string, offset, limit int, field, value, sortField, sortOrder string) ([]*Webhook, error) {
webhooks := []*Webhook{}
session := GetSession(owner, offset, limit, field, value, sortField, sortOrder)
err := session.Find(&webhooks, &Webhook{Organization: organization})
if err != nil {
panic(err)
return nil, err
}
return webhooks
return webhooks, nil
}
func getWebhooksByOrganization(organization string) []*Webhook {
func getWebhooksByOrganization(organization string) ([]*Webhook, error) {
webhooks := []*Webhook{}
err := adapter.Engine.Desc("created_time").Find(&webhooks, &Webhook{Organization: organization})
if err != nil {
panic(err)
return webhooks, err
}
return webhooks
return webhooks, nil
}
func getWebhook(owner string, name string) *Webhook {
func getWebhook(owner string, name string) (*Webhook, error) {
if owner == "" || name == "" {
return nil
return nil, nil
}
webhook := Webhook{Owner: owner, Name: name}
existed, err := adapter.Engine.Get(&webhook)
if err != nil {
panic(err)
return &webhook, err
}
if existed {
return &webhook
return &webhook, nil
} else {
return nil
return nil, nil
}
}
func GetWebhook(id string) *Webhook {
func GetWebhook(id string) (*Webhook, error) {
owner, name := util.GetOwnerAndNameFromId(id)
return getWebhook(owner, name)
}
func UpdateWebhook(id string, webhook *Webhook) bool {
func UpdateWebhook(id string, webhook *Webhook) (bool, error) {
owner, name := util.GetOwnerAndNameFromId(id)
if getWebhook(owner, name) == nil {
return false
if w, err := getWebhook(owner, name); err != nil {
return false, err
} else if w == nil {
return false, nil
}
affected, err := adapter.Engine.ID(core.PK{owner, name}).AllCols().Update(webhook)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func AddWebhook(webhook *Webhook) bool {
func AddWebhook(webhook *Webhook) (bool, error) {
affected, err := adapter.Engine.Insert(webhook)
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func DeleteWebhook(webhook *Webhook) bool {
func DeleteWebhook(webhook *Webhook) (bool, error) {
affected, err := adapter.Engine.ID(core.PK{webhook.Owner, webhook.Name}).Delete(&Webhook{})
if err != nil {
panic(err)
return false, err
}
return affected != 0
return affected != 0, nil
}
func (p *Webhook) GetId() string {