linters:
- staticcheck
text: "svc.IsAnInteractiveSession is deprecated: Use IsWindowsService instead."
-
"text/tabwriter"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/graceful"
"code.gitea.io/gitea/modules/log"
repo_module "code.gitea.io/gitea/modules/repository"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/storage"
+ auth_service "code.gitea.io/gitea/services/auth"
"code.gitea.io/gitea/services/auth/source/oauth2"
"github.com/urfave/cli"
log.Trace("Synchronizing repository releases (this may take a while)")
for page := 1; ; page++ {
repos, count, err := models.SearchRepositoryByName(&models.SearchRepoOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: models.RepositoryListDefaultPageSize,
Page: page,
},
return err
}
- return models.CreateLoginSource(&models.LoginSource{
- Type: models.LoginOAuth2,
+ return login.CreateSource(&login.Source{
+ Type: login.OAuth2,
Name: c.String("name"),
IsActive: true,
Cfg: parseOAuth2Config(c),
return err
}
- source, err := models.GetLoginSourceByID(c.Int64("id"))
+ source, err := login.GetSourceByID(c.Int64("id"))
if err != nil {
return err
}
oAuth2Config.CustomURLMapping = customURLMapping
source.Cfg = oAuth2Config
- return models.UpdateSource(source)
+ return login.UpdateSource(source)
}
func runListAuth(c *cli.Context) error {
return err
}
- loginSources, err := models.LoginSources()
+ loginSources, err := login.Sources()
if err != nil {
return err
w := tabwriter.NewWriter(os.Stdout, c.Int("min-width"), c.Int("tab-width"), c.Int("padding"), padChar, flags)
fmt.Fprintf(w, "ID\tName\tType\tEnabled\n")
for _, source := range loginSources {
- fmt.Fprintf(w, "%d\t%s\t%s\t%t\n", source.ID, source.Name, models.LoginNames[source.Type], source.IsActive)
+ fmt.Fprintf(w, "%d\t%s\t%s\t%t\n", source.ID, source.Name, source.Type.String(), source.IsActive)
}
w.Flush()
return err
}
- source, err := models.GetLoginSourceByID(c.Int64("id"))
+ source, err := login.GetSourceByID(c.Int64("id"))
if err != nil {
return err
}
- return models.DeleteSource(source)
+ return auth_service.DeleteLoginSource(source)
}
"fmt"
"strings"
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth/source/ldap"
"github.com/urfave/cli"
type (
authService struct {
initDB func() error
- createLoginSource func(loginSource *models.LoginSource) error
- updateLoginSource func(loginSource *models.LoginSource) error
- getLoginSourceByID func(id int64) (*models.LoginSource, error)
+ createLoginSource func(loginSource *login.Source) error
+ updateLoginSource func(loginSource *login.Source) error
+ getLoginSourceByID func(id int64) (*login.Source, error)
}
)
func newAuthService() *authService {
return &authService{
initDB: initDB,
- createLoginSource: models.CreateLoginSource,
- updateLoginSource: models.UpdateSource,
- getLoginSourceByID: models.GetLoginSourceByID,
+ createLoginSource: login.CreateSource,
+ updateLoginSource: login.UpdateSource,
+ getLoginSourceByID: login.GetSourceByID,
}
}
// parseLoginSource assigns values on loginSource according to command line flags.
-func parseLoginSource(c *cli.Context, loginSource *models.LoginSource) {
+func parseLoginSource(c *cli.Context, loginSource *login.Source) {
if c.IsSet("name") {
loginSource.Name = c.String("name")
}
// getLoginSource gets the login source by its id defined in the command line flags.
// It returns an error if the id is not set, does not match any source or if the source is not of expected type.
-func (a *authService) getLoginSource(c *cli.Context, loginType models.LoginType) (*models.LoginSource, error) {
+func (a *authService) getLoginSource(c *cli.Context, loginType login.Type) (*login.Source, error) {
if err := argsSet(c, "id"); err != nil {
return nil, err
}
}
if loginSource.Type != loginType {
- return nil, fmt.Errorf("Invalid authentication type. expected: %s, actual: %s", models.LoginNames[loginType], models.LoginNames[loginSource.Type])
+ return nil, fmt.Errorf("Invalid authentication type. expected: %s, actual: %s", loginType.String(), loginSource.Type.String())
}
return loginSource, nil
return err
}
- loginSource := &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource := &login.Source{
+ Type: login.LDAP,
IsActive: true, // active by default
Cfg: &ldap.Source{
Enabled: true, // always true
return err
}
- loginSource, err := a.getLoginSource(c, models.LoginLDAP)
+ loginSource, err := a.getLoginSource(c, login.LDAP)
if err != nil {
return err
}
return err
}
- loginSource := &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource := &login.Source{
+ Type: login.DLDAP,
IsActive: true, // active by default
Cfg: &ldap.Source{
Enabled: true, // always true
return err
}
- loginSource, err := a.getLoginSource(c, models.LoginDLDAP)
+ loginSource, err := a.getLoginSource(c, login.DLDAP)
if err != nil {
return err
}
import (
"testing"
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth/source/ldap"
"github.com/stretchr/testify/assert"
// Test cases
var cases = []struct {
args []string
- loginSource *models.LoginSource
+ loginSource *login.Source
errMsg string
}{
// case 0
"--synchronize-users",
"--page-size", "99",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Name: "ldap (via Bind DN) source full",
IsActive: false,
IsSyncEnabled: true,
"--user-filter", "(memberOf=cn=user-group,ou=example,dc=min-domain-bind,dc=org)",
"--email-attribute", "mail-bind min",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Name: "ldap (via Bind DN) source min",
IsActive: true,
Cfg: &ldap.Source{
for n, c := range cases {
// Mock functions.
- var createdLoginSource *models.LoginSource
+ var createdLoginSource *login.Source
service := &authService{
initDB: func() error {
return nil
},
- createLoginSource: func(loginSource *models.LoginSource) error {
+ createLoginSource: func(loginSource *login.Source) error {
createdLoginSource = loginSource
return nil
},
- updateLoginSource: func(loginSource *models.LoginSource) error {
+ updateLoginSource: func(loginSource *login.Source) error {
assert.FailNow(t, "case %d: should not call updateLoginSource", n)
return nil
},
- getLoginSourceByID: func(id int64) (*models.LoginSource, error) {
+ getLoginSourceByID: func(id int64) (*login.Source, error) {
assert.FailNow(t, "case %d: should not call getLoginSourceByID", n)
return nil, nil
},
// Test cases
var cases = []struct {
args []string
- loginSource *models.LoginSource
+ loginSource *login.Source
errMsg string
}{
// case 0
"--public-ssh-key-attribute", "publickey-simple full",
"--user-dn", "cn=%s,ou=Users,dc=full-domain-simple,dc=org",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Name: "ldap (simple auth) source full",
IsActive: false,
Cfg: &ldap.Source{
"--email-attribute", "mail-simple min",
"--user-dn", "cn=%s,ou=Users,dc=min-domain-simple,dc=org",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Name: "ldap (simple auth) source min",
IsActive: true,
Cfg: &ldap.Source{
for n, c := range cases {
// Mock functions.
- var createdLoginSource *models.LoginSource
+ var createdLoginSource *login.Source
service := &authService{
initDB: func() error {
return nil
},
- createLoginSource: func(loginSource *models.LoginSource) error {
+ createLoginSource: func(loginSource *login.Source) error {
createdLoginSource = loginSource
return nil
},
- updateLoginSource: func(loginSource *models.LoginSource) error {
+ updateLoginSource: func(loginSource *login.Source) error {
assert.FailNow(t, "case %d: should not call updateLoginSource", n)
return nil
},
- getLoginSourceByID: func(id int64) (*models.LoginSource, error) {
+ getLoginSourceByID: func(id int64) (*login.Source, error) {
assert.FailNow(t, "case %d: should not call getLoginSourceByID", n)
return nil, nil
},
var cases = []struct {
args []string
id int64
- existingLoginSource *models.LoginSource
- loginSource *models.LoginSource
+ existingLoginSource *login.Source
+ loginSource *login.Source
errMsg string
}{
// case 0
"--page-size", "99",
},
id: 23,
- existingLoginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ existingLoginSource: &login.Source{
+ Type: login.LDAP,
IsActive: true,
Cfg: &ldap.Source{
Enabled: true,
},
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Name: "ldap (via Bind DN) source full",
IsActive: false,
IsSyncEnabled: true,
"ldap-test",
"--id", "1",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{},
},
},
"--id", "1",
"--name", "ldap (via Bind DN) source",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Name: "ldap (via Bind DN) source",
Cfg: &ldap.Source{
Name: "ldap (via Bind DN) source",
"--id", "1",
"--not-active",
},
- existingLoginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ existingLoginSource: &login.Source{
+ Type: login.LDAP,
IsActive: true,
Cfg: &ldap.Source{},
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
IsActive: false,
Cfg: &ldap.Source{},
},
"--id", "1",
"--security-protocol", "LDAPS",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
SecurityProtocol: ldap.SecurityProtocol(1),
},
"--id", "1",
"--skip-tls-verify",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
SkipVerify: true,
},
"--id", "1",
"--host", "ldap-server",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
Host: "ldap-server",
},
"--id", "1",
"--port", "389",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
Port: 389,
},
"--id", "1",
"--user-search-base", "ou=Users,dc=domain,dc=org",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
UserBase: "ou=Users,dc=domain,dc=org",
},
"--id", "1",
"--user-filter", "(memberOf=cn=user-group,ou=example,dc=domain,dc=org)",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
Filter: "(memberOf=cn=user-group,ou=example,dc=domain,dc=org)",
},
"--id", "1",
"--admin-filter", "(memberOf=cn=admin-group,ou=example,dc=domain,dc=org)",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
AdminFilter: "(memberOf=cn=admin-group,ou=example,dc=domain,dc=org)",
},
"--id", "1",
"--username-attribute", "uid",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
AttributeUsername: "uid",
},
"--id", "1",
"--firstname-attribute", "givenName",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
AttributeName: "givenName",
},
"--id", "1",
"--surname-attribute", "sn",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
AttributeSurname: "sn",
},
"--id", "1",
"--email-attribute", "mail",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
AttributeMail: "mail",
},
"--id", "1",
"--attributes-in-bind",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
AttributesInBind: true,
},
"--id", "1",
"--public-ssh-key-attribute", "publickey",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
AttributeSSHPublicKey: "publickey",
},
"--id", "1",
"--bind-dn", "cn=readonly,dc=domain,dc=org",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
BindDN: "cn=readonly,dc=domain,dc=org",
},
"--id", "1",
"--bind-password", "secret",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
BindPassword: "secret",
},
"--id", "1",
"--synchronize-users",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
IsSyncEnabled: true,
Cfg: &ldap.Source{},
},
"--id", "1",
"--page-size", "12",
},
- loginSource: &models.LoginSource{
- Type: models.LoginLDAP,
+ loginSource: &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{
SearchPageSize: 12,
},
"ldap-test",
"--id", "1",
},
- existingLoginSource: &models.LoginSource{
- Type: models.LoginOAuth2,
+ existingLoginSource: &login.Source{
+ Type: login.OAuth2,
Cfg: &ldap.Source{},
},
errMsg: "Invalid authentication type. expected: LDAP (via BindDN), actual: OAuth2",
for n, c := range cases {
// Mock functions.
- var updatedLoginSource *models.LoginSource
+ var updatedLoginSource *login.Source
service := &authService{
initDB: func() error {
return nil
},
- createLoginSource: func(loginSource *models.LoginSource) error {
+ createLoginSource: func(loginSource *login.Source) error {
assert.FailNow(t, "case %d: should not call createLoginSource", n)
return nil
},
- updateLoginSource: func(loginSource *models.LoginSource) error {
+ updateLoginSource: func(loginSource *login.Source) error {
updatedLoginSource = loginSource
return nil
},
- getLoginSourceByID: func(id int64) (*models.LoginSource, error) {
+ getLoginSourceByID: func(id int64) (*login.Source, error) {
if c.id != 0 {
assert.Equal(t, c.id, id, "case %d: wrong id", n)
}
if c.existingLoginSource != nil {
return c.existingLoginSource, nil
}
- return &models.LoginSource{
- Type: models.LoginLDAP,
+ return &login.Source{
+ Type: login.LDAP,
Cfg: &ldap.Source{},
}, nil
},
var cases = []struct {
args []string
id int64
- existingLoginSource *models.LoginSource
- loginSource *models.LoginSource
+ existingLoginSource *login.Source
+ loginSource *login.Source
errMsg string
}{
// case 0
"--user-dn", "cn=%s,ou=Users,dc=full-domain-simple,dc=org",
},
id: 7,
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Name: "ldap (simple auth) source full",
IsActive: false,
Cfg: &ldap.Source{
"ldap-test",
"--id", "1",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{},
},
},
"--id", "1",
"--name", "ldap (simple auth) source",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Name: "ldap (simple auth) source",
Cfg: &ldap.Source{
Name: "ldap (simple auth) source",
"--id", "1",
"--not-active",
},
- existingLoginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ existingLoginSource: &login.Source{
+ Type: login.DLDAP,
IsActive: true,
Cfg: &ldap.Source{},
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
IsActive: false,
Cfg: &ldap.Source{},
},
"--id", "1",
"--security-protocol", "starttls",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
SecurityProtocol: ldap.SecurityProtocol(2),
},
"--id", "1",
"--skip-tls-verify",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
SkipVerify: true,
},
"--id", "1",
"--host", "ldap-server",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
Host: "ldap-server",
},
"--id", "1",
"--port", "987",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
Port: 987,
},
"--id", "1",
"--user-search-base", "ou=Users,dc=domain,dc=org",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
UserBase: "ou=Users,dc=domain,dc=org",
},
"--id", "1",
"--user-filter", "(&(objectClass=posixAccount)(cn=%s))",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
Filter: "(&(objectClass=posixAccount)(cn=%s))",
},
"--id", "1",
"--admin-filter", "(memberOf=cn=admin-group,ou=example,dc=domain,dc=org)",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
AdminFilter: "(memberOf=cn=admin-group,ou=example,dc=domain,dc=org)",
},
"--id", "1",
"--username-attribute", "uid",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
AttributeUsername: "uid",
},
"--id", "1",
"--firstname-attribute", "givenName",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
AttributeName: "givenName",
},
"--id", "1",
"--surname-attribute", "sn",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
AttributeSurname: "sn",
},
"--id", "1",
"--email-attribute", "mail",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
AttributeMail: "mail",
"--id", "1",
"--public-ssh-key-attribute", "publickey",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
AttributeSSHPublicKey: "publickey",
},
"--id", "1",
"--user-dn", "cn=%s,ou=Users,dc=domain,dc=org",
},
- loginSource: &models.LoginSource{
- Type: models.LoginDLDAP,
+ loginSource: &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{
UserDN: "cn=%s,ou=Users,dc=domain,dc=org",
},
"ldap-test",
"--id", "1",
},
- existingLoginSource: &models.LoginSource{
- Type: models.LoginPAM,
+ existingLoginSource: &login.Source{
+ Type: login.PAM,
Cfg: &ldap.Source{},
},
errMsg: "Invalid authentication type. expected: LDAP (simple auth), actual: PAM",
for n, c := range cases {
// Mock functions.
- var updatedLoginSource *models.LoginSource
+ var updatedLoginSource *login.Source
service := &authService{
initDB: func() error {
return nil
},
- createLoginSource: func(loginSource *models.LoginSource) error {
+ createLoginSource: func(loginSource *login.Source) error {
assert.FailNow(t, "case %d: should not call createLoginSource", n)
return nil
},
- updateLoginSource: func(loginSource *models.LoginSource) error {
+ updateLoginSource: func(loginSource *login.Source) error {
updatedLoginSource = loginSource
return nil
},
- getLoginSourceByID: func(id int64) (*models.LoginSource, error) {
+ getLoginSourceByID: func(id int64) (*login.Source, error) {
if c.id != 0 {
assert.Equal(t, c.id, id, "case %d: wrong id", n)
}
if c.existingLoginSource != nil {
return c.existingLoginSource, nil
}
- return &models.LoginSource{
- Type: models.LoginDLDAP,
+ return &login.Source{
+ Type: login.DLDAP,
Cfg: &ldap.Source{},
}, nil
},
func main() {
pathToGiteaRoot := "."
fixturesDir = filepath.Join(pathToGiteaRoot, "models", "fixtures")
- if err := db.CreateTestEngine(fixturesDir); err != nil {
+ if err := db.CreateTestEngine(db.FixturesOptions{
+ Dir: fixturesDir,
+ }); err != nil {
fmt.Printf("CreateTestEngine: %+v", err)
os.Exit(1)
}
db.HasEngine = true
//x.ShowSQL(true)
err = db.InitFixtures(
- path.Join(curDir, "models/fixtures/"),
+ db.FixturesOptions{
+ Dir: path.Join(curDir, "models/fixtures/"),
+ },
)
if err != nil {
fmt.Printf("Error initializing test database: %v\n", err)
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
api "code.gitea.io/gitea/modules/structs"
"github.com/stretchr/testify/assert"
assert.Len(t, createdApp.ClientID, 36)
assert.NotEmpty(t, createdApp.Created)
assert.EqualValues(t, appBody.RedirectURIs[0], createdApp.RedirectURIs[0])
- db.AssertExistsAndLoadBean(t, &models.OAuth2Application{UID: user.ID, Name: createdApp.Name})
+ db.AssertExistsAndLoadBean(t, &login.OAuth2Application{UID: user.ID, Name: createdApp.Name})
}
func testAPIListOAuth2Applications(t *testing.T) {
session := loginUser(t, user.Name)
token := getTokenForLoggedInUser(t, session)
- existApp := db.AssertExistsAndLoadBean(t, &models.OAuth2Application{
+ existApp := db.AssertExistsAndLoadBean(t, &login.OAuth2Application{
UID: user.ID,
Name: "test-app-1",
RedirectURIs: []string{
"http://www.google.com",
},
- }).(*models.OAuth2Application)
+ }).(*login.OAuth2Application)
urlStr := fmt.Sprintf("/api/v1/user/applications/oauth2?token=%s", token)
req := NewRequest(t, "GET", urlStr)
assert.Len(t, expectedApp.ClientID, 36)
assert.Empty(t, expectedApp.ClientSecret)
assert.EqualValues(t, existApp.RedirectURIs[0], expectedApp.RedirectURIs[0])
- db.AssertExistsAndLoadBean(t, &models.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
+ db.AssertExistsAndLoadBean(t, &login.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
}
func testAPIDeleteOAuth2Application(t *testing.T) {
session := loginUser(t, user.Name)
token := getTokenForLoggedInUser(t, session)
- oldApp := db.AssertExistsAndLoadBean(t, &models.OAuth2Application{
+ oldApp := db.AssertExistsAndLoadBean(t, &login.OAuth2Application{
UID: user.ID,
Name: "test-app-1",
- }).(*models.OAuth2Application)
+ }).(*login.OAuth2Application)
urlStr := fmt.Sprintf("/api/v1/user/applications/oauth2/%d?token=%s", oldApp.ID, token)
req := NewRequest(t, "DELETE", urlStr)
session.MakeRequest(t, req, http.StatusNoContent)
- db.AssertNotExistsBean(t, &models.OAuth2Application{UID: oldApp.UID, Name: oldApp.Name})
+ db.AssertNotExistsBean(t, &login.OAuth2Application{UID: oldApp.UID, Name: oldApp.Name})
// Delete again will return not found
req = NewRequest(t, "DELETE", urlStr)
session := loginUser(t, user.Name)
token := getTokenForLoggedInUser(t, session)
- existApp := db.AssertExistsAndLoadBean(t, &models.OAuth2Application{
+ existApp := db.AssertExistsAndLoadBean(t, &login.OAuth2Application{
UID: user.ID,
Name: "test-app-1",
RedirectURIs: []string{
"http://www.google.com",
},
- }).(*models.OAuth2Application)
+ }).(*login.OAuth2Application)
urlStr := fmt.Sprintf("/api/v1/user/applications/oauth2/%d?token=%s", existApp.ID, token)
req := NewRequest(t, "GET", urlStr)
assert.Empty(t, expectedApp.ClientSecret)
assert.Len(t, expectedApp.RedirectURIs, 1)
assert.EqualValues(t, existApp.RedirectURIs[0], expectedApp.RedirectURIs[0])
- db.AssertExistsAndLoadBean(t, &models.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
+ db.AssertExistsAndLoadBean(t, &login.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
}
func testAPIUpdateOAuth2Application(t *testing.T) {
user := db.AssertExistsAndLoadBean(t, &models.User{ID: 2}).(*models.User)
- existApp := db.AssertExistsAndLoadBean(t, &models.OAuth2Application{
+ existApp := db.AssertExistsAndLoadBean(t, &login.OAuth2Application{
UID: user.ID,
Name: "test-app-1",
RedirectURIs: []string{
"http://www.google.com",
},
- }).(*models.OAuth2Application)
+ }).(*login.OAuth2Application)
appBody := api.CreateOAuth2ApplicationOptions{
Name: "test-app-1",
assert.Len(t, expectedApp.RedirectURIs, 2)
assert.EqualValues(t, expectedApp.RedirectURIs[0], appBody.RedirectURIs[0])
assert.EqualValues(t, expectedApp.RedirectURIs[1], appBody.RedirectURIs[1])
- db.AssertExistsAndLoadBean(t, &models.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
+ db.AssertExistsAndLoadBean(t, &login.OAuth2Application{ID: expectedApp.ID, Name: expectedApp.Name})
}
}
err := db.InitFixtures(
- path.Join(filepath.Dir(setting.AppPath), "models/fixtures/"),
+ db.FixturesOptions{
+ Dir: filepath.Join(filepath.Dir(setting.AppPath), "models/fixtures/"),
+ },
)
if err != nil {
fmt.Printf("Error initializing test database: %v\n", err)
// refreshCollaboratorAccesses retrieves repository collaborations with their access modes.
func (repo *Repository) refreshCollaboratorAccesses(e db.Engine, accessMap map[int64]*userAccess) error {
- collaborators, err := repo.getCollaborators(e, ListOptions{})
+ collaborators, err := repo.getCollaborators(e, db.ListOptions{})
if err != nil {
return fmt.Errorf("getCollaborations: %v", err)
}
// CommitStatusOptions holds the options for query commit statuses
type CommitStatusOptions struct {
- ListOptions
+ db.ListOptions
State string
SortType string
}
}
countSession := listCommitStatusesStatement(repo, sha, opts)
- countSession = setSessionPagination(countSession, opts)
+ countSession = db.SetSessionPagination(countSession, opts)
maxResults, err := countSession.Count(new(CommitStatus))
if err != nil {
log.Error("Count PRs: %v", err)
statuses := make([]*CommitStatus, 0, opts.PageSize)
findSession := listCommitStatusesStatement(repo, sha, opts)
- findSession = setSessionPagination(findSession, opts)
+ findSession = db.SetSessionPagination(findSession, opts)
sortCommitStatusesSession(findSession, opts.SortType)
return statuses, maxResults, findSession.Find(&statuses)
}
}
// GetLatestCommitStatus returns all statuses with a unique context for a given commit.
-func GetLatestCommitStatus(repoID int64, sha string, listOptions ListOptions) ([]*CommitStatus, error) {
+func GetLatestCommitStatus(repoID int64, sha string, listOptions db.ListOptions) ([]*CommitStatus, error) {
return getLatestCommitStatus(db.GetEngine(db.DefaultContext), repoID, sha, listOptions)
}
-func getLatestCommitStatus(e db.Engine, repoID int64, sha string, listOptions ListOptions) ([]*CommitStatus, error) {
+func getLatestCommitStatus(e db.Engine, repoID int64, sha string, listOptions db.ListOptions) ([]*CommitStatus, error) {
ids := make([]int64, 0, 10)
sess := e.Table(&CommitStatus{}).
Where("repo_id = ?", repoID).And("sha = ?", sha).
Select("max( id ) as id").
GroupBy("context_hash").OrderBy("max( id ) desc")
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
err := sess.Find(&ids)
if err != nil {
commit := &SignCommitWithStatuses{
SignCommit: c,
}
- statuses, err := GetLatestCommitStatus(repo.ID, commit.ID.String(), ListOptions{})
+ statuses, err := GetLatestCommitStatus(repo.ID, commit.ID.String(), db.ListOptions{})
if err != nil {
log.Error("GetLatestCommitStatus: %v", err)
} else {
sha1 := "1234123412341234123412341234123412341234"
- statuses, maxResults, err := GetCommitStatuses(repo1, sha1, &CommitStatusOptions{ListOptions: ListOptions{Page: 1, PageSize: 50}})
+ statuses, maxResults, err := GetCommitStatuses(repo1, sha1, &CommitStatusOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 50}})
assert.NoError(t, err)
assert.Equal(t, int(maxResults), 5)
assert.Len(t, statuses, 5)
--- /dev/null
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package db
+
+import (
+ "code.gitea.io/gitea/modules/setting"
+
+ "xorm.io/xorm"
+)
+
+// Paginator is the base for different ListOptions types
+type Paginator interface {
+ GetSkipTake() (skip, take int)
+ GetStartEnd() (start, end int)
+}
+
+// GetPaginatedSession creates a paginated database session
+func GetPaginatedSession(p Paginator) *xorm.Session {
+ skip, take := p.GetSkipTake()
+
+ return x.Limit(take, skip)
+}
+
+// SetSessionPagination sets pagination for a database session
+func SetSessionPagination(sess *xorm.Session, p Paginator) *xorm.Session {
+ skip, take := p.GetSkipTake()
+
+ return sess.Limit(take, skip)
+}
+
+// SetEnginePagination sets pagination for a database engine
+func SetEnginePagination(e Engine, p Paginator) Engine {
+ skip, take := p.GetSkipTake()
+
+ return e.Limit(take, skip)
+}
+
+// ListOptions options to paginate results
+type ListOptions struct {
+ PageSize int
+ Page int // start from 1
+}
+
+// GetSkipTake returns the skip and take values
+func (opts *ListOptions) GetSkipTake() (skip, take int) {
+ opts.SetDefaultValues()
+ return (opts.Page - 1) * opts.PageSize, opts.PageSize
+}
+
+// GetStartEnd returns the start and end of the ListOptions
+func (opts *ListOptions) GetStartEnd() (start, end int) {
+ start, take := opts.GetSkipTake()
+ end = start + take
+ return
+}
+
+// SetDefaultValues sets default values
+func (opts *ListOptions) SetDefaultValues() {
+ if opts.PageSize <= 0 {
+ opts.PageSize = setting.API.DefaultPagingNum
+ }
+ if opts.PageSize > setting.API.MaxResponseItems {
+ opts.PageSize = setting.API.MaxResponseItems
+ }
+ if opts.Page <= 0 {
+ opts.Page = 1
+ }
+}
+
+// AbsoluteListOptions absolute options to paginate results
+type AbsoluteListOptions struct {
+ skip int
+ take int
+}
+
+// NewAbsoluteListOptions creates a list option with applied limits
+func NewAbsoluteListOptions(skip, take int) *AbsoluteListOptions {
+ if skip < 0 {
+ skip = 0
+ }
+ if take <= 0 {
+ take = setting.API.DefaultPagingNum
+ }
+ if take > setting.API.MaxResponseItems {
+ take = setting.API.MaxResponseItems
+ }
+ return &AbsoluteListOptions{skip, take}
+}
+
+// GetSkipTake returns the skip and take values
+func (opts *AbsoluteListOptions) GetSkipTake() (skip, take int) {
+ return opts.skip, opts.take
+}
+
+// GetStartEnd returns the start and end values
+func (opts *AbsoluteListOptions) GetStartEnd() (start, end int) {
+ return opts.skip, opts.skip + opts.take
+}
--- /dev/null
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package db
+
+import (
+ "testing"
+
+ "code.gitea.io/gitea/modules/setting"
+
+ "github.com/stretchr/testify/assert"
+)
+
+func TestPaginator(t *testing.T) {
+ cases := []struct {
+ Paginator
+ Skip int
+ Take int
+ Start int
+ End int
+ }{
+ {
+ Paginator: &ListOptions{Page: -1, PageSize: -1},
+ Skip: 0,
+ Take: setting.API.DefaultPagingNum,
+ Start: 0,
+ End: setting.API.DefaultPagingNum,
+ },
+ {
+ Paginator: &ListOptions{Page: 2, PageSize: 10},
+ Skip: 10,
+ Take: 10,
+ Start: 10,
+ End: 20,
+ },
+ {
+ Paginator: NewAbsoluteListOptions(-1, -1),
+ Skip: 0,
+ Take: setting.API.DefaultPagingNum,
+ Start: 0,
+ End: setting.API.DefaultPagingNum,
+ },
+ {
+ Paginator: NewAbsoluteListOptions(2, 10),
+ Skip: 2,
+ Take: 10,
+ Start: 2,
+ End: 12,
+ },
+ }
+
+ for _, c := range cases {
+ skip, take := c.Paginator.GetSkipTake()
+ start, end := c.Paginator.GetStartEnd()
+
+ assert.Equal(t, c.Skip, skip)
+ assert.Equal(t, c.Take, take)
+ assert.Equal(t, c.Start, start)
+ assert.Equal(t, c.End, end)
+ }
+}
var fixtures *testfixtures.Loader
// InitFixtures initialize test fixtures for a test database
-func InitFixtures(dir string, engine ...*xorm.Engine) (err error) {
+func InitFixtures(opts FixturesOptions, engine ...*xorm.Engine) (err error) {
e := x
if len(engine) == 1 {
e = engine[0]
}
- testfiles := testfixtures.Directory(dir)
+ var testfiles func(*testfixtures.Loader) error
+ if opts.Dir != "" {
+ testfiles = testfixtures.Directory(opts.Dir)
+ } else {
+ testfiles = testfixtures.Files(opts.Files...)
+ }
dialect := "unknown"
switch e.Dialect().URI().DBType {
case schemas.POSTGRES:
// MainTest a reusable TestMain(..) function for unit tests that need to use a
// test database. Creates the test database, and sets necessary settings.
-func MainTest(m *testing.M, pathToGiteaRoot string) {
+func MainTest(m *testing.M, pathToGiteaRoot string, fixtureFiles ...string) {
var err error
giteaRoot = pathToGiteaRoot
fixturesDir = filepath.Join(pathToGiteaRoot, "models", "fixtures")
- if err = CreateTestEngine(fixturesDir); err != nil {
+
+ var opts FixturesOptions
+ if len(fixtureFiles) == 0 {
+ opts.Dir = fixturesDir
+ } else {
+ for _, f := range fixtureFiles {
+ opts.Files = append(opts.Files, filepath.Join(fixturesDir, f))
+ }
+ }
+
+ if err = CreateTestEngine(opts); err != nil {
fatalTestError("Error creating test engine: %v\n", err)
}
os.Exit(exitStatus)
}
+// FixturesOptions fixtures needs to be loaded options
+type FixturesOptions struct {
+ Dir string
+ Files []string
+}
+
// CreateTestEngine creates a memory database and loads the fixture data from fixturesDir
-func CreateTestEngine(fixturesDir string) error {
+func CreateTestEngine(opts FixturesOptions) error {
var err error
x, err = xorm.NewEngine("sqlite3", "file::memory:?cache=shared&_txlock=immediate")
if err != nil {
e: x,
}
- return InitFixtures(fixturesDir)
+ return InitFixtures(opts)
}
// PrepareTestDatabase load test fixtures into test database
return fmt.Sprintf("attachment does not exist [id: %d, uuid: %s]", err.ID, err.UUID)
}
-// .____ .__ _________
-// | | ____ ____ |__| ____ / _____/ ____ __ _________ ____ ____
-// | | / _ \ / ___\| |/ \ \_____ \ / _ \| | \_ __ \_/ ___\/ __ \
-// | |__( <_> ) /_/ > | | \ / ( <_> ) | /| | \/\ \__\ ___/
-// |_______ \____/\___ /|__|___| / /_______ /\____/|____/ |__| \___ >___ >
-// \/ /_____/ \/ \/ \/ \/
-
-// ErrLoginSourceNotExist represents a "LoginSourceNotExist" kind of error.
-type ErrLoginSourceNotExist struct {
- ID int64
-}
-
-// IsErrLoginSourceNotExist checks if an error is a ErrLoginSourceNotExist.
-func IsErrLoginSourceNotExist(err error) bool {
- _, ok := err.(ErrLoginSourceNotExist)
- return ok
-}
-
-func (err ErrLoginSourceNotExist) Error() string {
- return fmt.Sprintf("login source does not exist [id: %d]", err.ID)
-}
-
-// ErrLoginSourceAlreadyExist represents a "LoginSourceAlreadyExist" kind of error.
-type ErrLoginSourceAlreadyExist struct {
- Name string
-}
-
-// IsErrLoginSourceAlreadyExist checks if an error is a ErrLoginSourceAlreadyExist.
-func IsErrLoginSourceAlreadyExist(err error) bool {
- _, ok := err.(ErrLoginSourceAlreadyExist)
- return ok
-}
-
-func (err ErrLoginSourceAlreadyExist) Error() string {
- return fmt.Sprintf("login source already exists [name: %s]", err.Name)
-}
-
-// ErrLoginSourceInUse represents a "LoginSourceInUse" kind of error.
-type ErrLoginSourceInUse struct {
- ID int64
-}
-
-// IsErrLoginSourceInUse checks if an error is a ErrLoginSourceInUse.
-func IsErrLoginSourceInUse(err error) bool {
- _, ok := err.(ErrLoginSourceInUse)
- return ok
-}
-
-func (err ErrLoginSourceInUse) Error() string {
- return fmt.Sprintf("login source is still used by some users [id: %d]", err.ID)
-}
-
// ___________
// \__ ___/___ _____ _____
// | |_/ __ \\__ \ / \
err.UserID,
err.RepoID)
}
-
-// ________ _____ __ .__
-// \_____ \ / _ \ __ ___/ |_| |__
-// / | \ / /_\ \| | \ __\ | \
-// / | \/ | \ | /| | | Y \
-// \_______ /\____|__ /____/ |__| |___| /
-// \/ \/ \/
-
-// ErrOAuthClientIDInvalid will be thrown if client id cannot be found
-type ErrOAuthClientIDInvalid struct {
- ClientID string
-}
-
-// IsErrOauthClientIDInvalid checks if an error is a ErrReviewNotExist.
-func IsErrOauthClientIDInvalid(err error) bool {
- _, ok := err.(ErrOAuthClientIDInvalid)
- return ok
-}
-
-// Error returns the error message
-func (err ErrOAuthClientIDInvalid) Error() string {
- return fmt.Sprintf("Client ID invalid [Client ID: %s]", err.ClientID)
-}
-
-// ErrOAuthApplicationNotFound will be thrown if id cannot be found
-type ErrOAuthApplicationNotFound struct {
- ID int64
-}
-
-// IsErrOAuthApplicationNotFound checks if an error is a ErrReviewNotExist.
-func IsErrOAuthApplicationNotFound(err error) bool {
- _, ok := err.(ErrOAuthApplicationNotFound)
- return ok
-}
-
-// Error returns the error message
-func (err ErrOAuthApplicationNotFound) Error() string {
- return fmt.Sprintf("OAuth application not found [ID: %d]", err.ID)
-}
"time"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/structs"
"github.com/markbates/goth"
// UpdateExternalUser updates external user's information
func UpdateExternalUser(user *User, gothUser goth.User) error {
- loginSource, err := GetActiveOAuth2LoginSourceByName(gothUser.Provider)
+ loginSource, err := login.GetActiveOAuth2LoginSourceByName(gothUser.Provider)
if err != nil {
return err
}
}
// ListGPGKeys returns a list of public keys belongs to given user.
-func ListGPGKeys(uid int64, listOptions ListOptions) ([]*GPGKey, error) {
+func ListGPGKeys(uid int64, listOptions db.ListOptions) ([]*GPGKey, error) {
return listGPGKeys(db.GetEngine(db.DefaultContext), uid, listOptions)
}
-func listGPGKeys(e db.Engine, uid int64, listOptions ListOptions) ([]*GPGKey, error) {
+func listGPGKeys(e db.Engine, uid int64, listOptions db.ListOptions) ([]*GPGKey, error) {
sess := e.Table(&GPGKey{}).Where("owner_id=? AND primary_key_id=''", uid)
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
}
keys := make([]*GPGKey, 0, 2)
"hash"
"strings"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
// Now try to associate the signature with the committer, if present
if committer.ID != 0 {
- keys, err := ListGPGKeys(committer.ID, ListOptions{})
+ keys, err := ListGPGKeys(committer.ID, db.ListOptions{})
if err != nil { // Skipping failed to get gpg keys of user
log.Error("ListGPGKeys: %v", err)
return &CommitVerification{
// IssuesOptions represents options of an issue.
type IssuesOptions struct {
- ListOptions
+ db.ListOptions
RepoIDs []int64 // include all repos if empty
AssigneeID int64
PosterID int64
// FindCommentsOptions describes the conditions to Find comments
type FindCommentsOptions struct {
- ListOptions
+ db.ListOptions
RepoID int64
IssueID int64
ReviewID int64
}
if opts.Page != 0 {
- sess = setSessionPagination(sess, opts)
+ sess = db.SetSessionPagination(sess, opts)
}
// WARNING: If you change this order you will need to fix createCodeComment
Find(&labels)
}
-func getLabelsByRepoID(e db.Engine, repoID int64, sortType string, listOptions ListOptions) ([]*Label, error) {
+func getLabelsByRepoID(e db.Engine, repoID int64, sortType string, listOptions db.ListOptions) ([]*Label, error) {
if repoID <= 0 {
return nil, ErrRepoLabelNotExist{0, repoID}
}
}
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
}
return labels, sess.Find(&labels)
}
// GetLabelsByRepoID returns all labels that belong to given repository by ID.
-func GetLabelsByRepoID(repoID int64, sortType string, listOptions ListOptions) ([]*Label, error) {
+func GetLabelsByRepoID(repoID int64, sortType string, listOptions db.ListOptions) ([]*Label, error) {
return getLabelsByRepoID(db.GetEngine(db.DefaultContext), repoID, sortType, listOptions)
}
Find(&labels)
}
-func getLabelsByOrgID(e db.Engine, orgID int64, sortType string, listOptions ListOptions) ([]*Label, error) {
+func getLabelsByOrgID(e db.Engine, orgID int64, sortType string, listOptions db.ListOptions) ([]*Label, error) {
if orgID <= 0 {
return nil, ErrOrgLabelNotExist{0, orgID}
}
}
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
}
return labels, sess.Find(&labels)
}
// GetLabelsByOrgID returns all labels that belong to given organization by ID.
-func GetLabelsByOrgID(orgID int64, sortType string, listOptions ListOptions) ([]*Label, error) {
+func GetLabelsByOrgID(orgID int64, sortType string, listOptions db.ListOptions) ([]*Label, error) {
return getLabelsByOrgID(db.GetEngine(db.DefaultContext), orgID, sortType, listOptions)
}
func TestGetLabelsByRepoID(t *testing.T) {
assert.NoError(t, db.PrepareTestDatabase())
testSuccess := func(repoID int64, sortType string, expectedIssueIDs []int64) {
- labels, err := GetLabelsByRepoID(repoID, sortType, ListOptions{})
+ labels, err := GetLabelsByRepoID(repoID, sortType, db.ListOptions{})
assert.NoError(t, err)
assert.Len(t, labels, len(expectedIssueIDs))
for i, label := range labels {
func TestGetLabelsByOrgID(t *testing.T) {
assert.NoError(t, db.PrepareTestDatabase())
testSuccess := func(orgID int64, sortType string, expectedIssueIDs []int64) {
- labels, err := GetLabelsByOrgID(orgID, sortType, ListOptions{})
+ labels, err := GetLabelsByOrgID(orgID, sortType, db.ListOptions{})
assert.NoError(t, err)
assert.Len(t, labels, len(expectedIssueIDs))
for i, label := range labels {
testSuccess(3, "default", []int64{3, 4})
var err error
- _, err = GetLabelsByOrgID(0, "leastissues", ListOptions{})
+ _, err = GetLabelsByOrgID(0, "leastissues", db.ListOptions{})
assert.True(t, IsErrOrgLabelNotExist(err))
- _, err = GetLabelsByOrgID(-1, "leastissues", ListOptions{})
+ _, err = GetLabelsByOrgID(-1, "leastissues", db.ListOptions{})
assert.True(t, IsErrOrgLabelNotExist(err))
}
// GetMilestonesOption contain options to get milestones
type GetMilestonesOption struct {
- ListOptions
+ db.ListOptions
RepoID int64
State api.StateType
Name string
sess := db.GetEngine(db.DefaultContext).Where(opts.toCond())
if opts.Page != 0 {
- sess = setSessionPagination(sess, &opts)
+ sess = db.SetSessionPagination(sess, &opts)
}
switch opts.SortType {
test := func(sortType string, sortCond func(*Milestone) int) {
for _, page := range []int{0, 1} {
milestones, _, err := GetMilestones(GetMilestonesOption{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: page,
PageSize: setting.UI.IssuePagingNum,
},
assert.True(t, sort.IntsAreSorted(values))
milestones, _, err = GetMilestones(GetMilestonesOption{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: page,
PageSize: setting.UI.IssuePagingNum,
},
// FindReactionsOptions describes the conditions to Find reactions
type FindReactionsOptions struct {
- ListOptions
+ db.ListOptions
IssueID int64
CommentID int64
UserID int64
}
// FindIssueReactions returns a ReactionList of all reactions from an issue
-func FindIssueReactions(issue *Issue, listOptions ListOptions) (ReactionList, error) {
+func FindIssueReactions(issue *Issue, listOptions db.ListOptions) (ReactionList, error) {
return findReactions(db.GetEngine(db.DefaultContext), FindReactionsOptions{
ListOptions: listOptions,
IssueID: issue.ID,
In("reaction.`type`", setting.UI.Reactions).
Asc("reaction.issue_id", "reaction.comment_id", "reaction.created_unix", "reaction.id")
if opts.Page != 0 {
- e = setEnginePagination(e, &opts)
+ e = db.SetEnginePagination(e, &opts)
reactions := make([]*Reaction, 0, opts.PageSize)
return reactions, e.Find(&reactions)
}
// GetUserStopwatches return list of all stopwatches of a user
-func GetUserStopwatches(userID int64, listOptions ListOptions) ([]*Stopwatch, error) {
+func GetUserStopwatches(userID int64, listOptions db.ListOptions) ([]*Stopwatch, error) {
sws := make([]*Stopwatch, 0, 8)
sess := db.GetEngine(db.DefaultContext).Where("stopwatch.user_id = ?", userID)
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
}
err := sess.Find(&sws)
IssuesOptions{
RepoIDs: []int64{1, 3},
SortType: "oldest",
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 4,
},
{
IssuesOptions{
LabelIDs: []int64{1},
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 4,
},
{
IssuesOptions{
LabelIDs: []int64{1, 2},
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 4,
},
// FindTrackedTimesOptions represent the filters for tracked times. If an ID is 0 it will be ignored.
type FindTrackedTimesOptions struct {
- ListOptions
+ db.ListOptions
IssueID int64
UserID int64
RepositoryID int64
sess = sess.Where(opts.toCond())
if opts.Page != 0 {
- sess = setEnginePagination(sess, opts)
+ sess = db.SetEnginePagination(sess, opts)
}
return sess
}
// GetIssueWatchers returns watchers/unwatchers of a given issue
-func GetIssueWatchers(issueID int64, listOptions ListOptions) (IssueWatchList, error) {
+func GetIssueWatchers(issueID int64, listOptions db.ListOptions) (IssueWatchList, error) {
return getIssueWatchers(db.GetEngine(db.DefaultContext), issueID, listOptions)
}
-func getIssueWatchers(e db.Engine, issueID int64, listOptions ListOptions) (IssueWatchList, error) {
+func getIssueWatchers(e db.Engine, issueID int64, listOptions db.ListOptions) (IssueWatchList, error) {
sess := e.
Where("`issue_watch`.issue_id = ?", issueID).
And("`issue_watch`.is_watching = ?", true).
Join("INNER", "`user`", "`user`.id = `issue_watch`.user_id")
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
watches := make([]*IssueWatch, 0, listOptions.PageSize)
return watches, sess.Find(&watches)
}
func TestGetIssueWatchers(t *testing.T) {
assert.NoError(t, db.PrepareTestDatabase())
- iws, err := GetIssueWatchers(1, ListOptions{})
+ iws, err := GetIssueWatchers(1, db.ListOptions{})
assert.NoError(t, err)
// Watcher is inactive, thus 0
assert.Len(t, iws, 0)
- iws, err = GetIssueWatchers(2, ListOptions{})
+ iws, err = GetIssueWatchers(2, db.ListOptions{})
assert.NoError(t, err)
// Watcher is explicit not watching
assert.Len(t, iws, 0)
- iws, err = GetIssueWatchers(5, ListOptions{})
+ iws, err = GetIssueWatchers(5, db.ListOptions{})
assert.NoError(t, err)
// Issue has no Watchers
assert.Len(t, iws, 0)
- iws, err = GetIssueWatchers(7, ListOptions{})
+ iws, err = GetIssueWatchers(7, db.ListOptions{})
assert.NoError(t, err)
// Issue has one watcher
assert.Len(t, iws, 1)
+++ /dev/null
-// Copyright 2020 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package models
-
-import (
- "code.gitea.io/gitea/models/db"
- "code.gitea.io/gitea/modules/setting"
-
- "xorm.io/xorm"
-)
-
-// Paginator is the base for different ListOptions types
-type Paginator interface {
- GetSkipTake() (skip, take int)
- GetStartEnd() (start, end int)
-}
-
-// getPaginatedSession creates a paginated database session
-func getPaginatedSession(p Paginator) *xorm.Session {
- skip, take := p.GetSkipTake()
-
- return db.GetEngine(db.DefaultContext).Limit(take, skip)
-}
-
-// setSessionPagination sets pagination for a database session
-func setSessionPagination(sess *xorm.Session, p Paginator) *xorm.Session {
- skip, take := p.GetSkipTake()
-
- return sess.Limit(take, skip)
-}
-
-// setSessionPagination sets pagination for a database engine
-func setEnginePagination(e db.Engine, p Paginator) db.Engine {
- skip, take := p.GetSkipTake()
-
- return e.Limit(take, skip)
-}
-
-// ListOptions options to paginate results
-type ListOptions struct {
- PageSize int
- Page int // start from 1
-}
-
-// GetSkipTake returns the skip and take values
-func (opts *ListOptions) GetSkipTake() (skip, take int) {
- opts.setDefaultValues()
- return (opts.Page - 1) * opts.PageSize, opts.PageSize
-}
-
-// GetStartEnd returns the start and end of the ListOptions
-func (opts *ListOptions) GetStartEnd() (start, end int) {
- start, take := opts.GetSkipTake()
- end = start + take
- return
-}
-
-func (opts *ListOptions) setDefaultValues() {
- if opts.PageSize <= 0 {
- opts.PageSize = setting.API.DefaultPagingNum
- }
- if opts.PageSize > setting.API.MaxResponseItems {
- opts.PageSize = setting.API.MaxResponseItems
- }
- if opts.Page <= 0 {
- opts.Page = 1
- }
-}
-
-// AbsoluteListOptions absolute options to paginate results
-type AbsoluteListOptions struct {
- skip int
- take int
-}
-
-// NewAbsoluteListOptions creates a list option with applied limits
-func NewAbsoluteListOptions(skip, take int) *AbsoluteListOptions {
- if skip < 0 {
- skip = 0
- }
- if take <= 0 {
- take = setting.API.DefaultPagingNum
- }
- if take > setting.API.MaxResponseItems {
- take = setting.API.MaxResponseItems
- }
- return &AbsoluteListOptions{skip, take}
-}
-
-// GetSkipTake returns the skip and take values
-func (opts *AbsoluteListOptions) GetSkipTake() (skip, take int) {
- return opts.skip, opts.take
-}
-
-// GetStartEnd returns the start and end values
-func (opts *AbsoluteListOptions) GetStartEnd() (start, end int) {
- return opts.skip, opts.skip + opts.take
-}
+++ /dev/null
-// Copyright 2021 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package models
-
-import (
- "testing"
-
- "code.gitea.io/gitea/modules/setting"
-
- "github.com/stretchr/testify/assert"
-)
-
-func TestPaginator(t *testing.T) {
- cases := []struct {
- Paginator
- Skip int
- Take int
- Start int
- End int
- }{
- {
- Paginator: &ListOptions{Page: -1, PageSize: -1},
- Skip: 0,
- Take: setting.API.DefaultPagingNum,
- Start: 0,
- End: setting.API.DefaultPagingNum,
- },
- {
- Paginator: &ListOptions{Page: 2, PageSize: 10},
- Skip: 10,
- Take: 10,
- Start: 10,
- End: 20,
- },
- {
- Paginator: NewAbsoluteListOptions(-1, -1),
- Skip: 0,
- Take: setting.API.DefaultPagingNum,
- Start: 0,
- End: setting.API.DefaultPagingNum,
- },
- {
- Paginator: NewAbsoluteListOptions(2, 10),
- Skip: 2,
- Take: 10,
- Start: 2,
- End: 12,
- },
- }
-
- for _, c := range cases {
- skip, take := c.Paginator.GetSkipTake()
- start, end := c.Paginator.GetStartEnd()
-
- assert.Equal(t, c.Skip, skip)
- assert.Equal(t, c.Take, take)
- assert.Equal(t, c.Start, start)
- assert.Equal(t, c.End, end)
- }
-}
--- /dev/null
+// Copyright 2020 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package login
+
+import (
+ "path/filepath"
+ "testing"
+
+ "code.gitea.io/gitea/models/db"
+)
+
+func TestMain(m *testing.M) {
+ db.MainTest(m, filepath.Join("..", ".."),
+ "login_source.yml",
+ "oauth2_application.yml",
+ "oauth2_authorization_code.yml",
+ "oauth2_grant.yml",
+ )
+}
--- /dev/null
+// Copyright 2017 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package login
+
+import (
+ "fmt"
+
+ "code.gitea.io/gitea/models/db"
+)
+
+// ________ _____ __ .__
+// \_____ \ / _ \ __ ___/ |_| |__
+// / | \ / /_\ \| | \ __\ | \
+// / | \/ | \ | /| | | Y \
+// \_______ /\____|__ /____/ |__| |___| /
+// \/ \/ \/
+
+// ErrOAuthClientIDInvalid will be thrown if client id cannot be found
+type ErrOAuthClientIDInvalid struct {
+ ClientID string
+}
+
+// IsErrOauthClientIDInvalid checks if an error is a ErrReviewNotExist.
+func IsErrOauthClientIDInvalid(err error) bool {
+ _, ok := err.(ErrOAuthClientIDInvalid)
+ return ok
+}
+
+// Error returns the error message
+func (err ErrOAuthClientIDInvalid) Error() string {
+ return fmt.Sprintf("Client ID invalid [Client ID: %s]", err.ClientID)
+}
+
+// ErrOAuthApplicationNotFound will be thrown if id cannot be found
+type ErrOAuthApplicationNotFound struct {
+ ID int64
+}
+
+// IsErrOAuthApplicationNotFound checks if an error is a ErrReviewNotExist.
+func IsErrOAuthApplicationNotFound(err error) bool {
+ _, ok := err.(ErrOAuthApplicationNotFound)
+ return ok
+}
+
+// Error returns the error message
+func (err ErrOAuthApplicationNotFound) Error() string {
+ return fmt.Sprintf("OAuth application not found [ID: %d]", err.ID)
+}
+
+// GetActiveOAuth2ProviderLoginSources returns all actived LoginOAuth2 sources
+func GetActiveOAuth2ProviderLoginSources() ([]*Source, error) {
+ sources := make([]*Source, 0, 1)
+ if err := db.GetEngine(db.DefaultContext).Where("is_active = ? and type = ?", true, OAuth2).Find(&sources); err != nil {
+ return nil, err
+ }
+ return sources, nil
+}
+
+// GetActiveOAuth2LoginSourceByName returns a OAuth2 LoginSource based on the given name
+func GetActiveOAuth2LoginSourceByName(name string) (*Source, error) {
+ loginSource := new(Source)
+ has, err := db.GetEngine(db.DefaultContext).Where("name = ? and type = ? and is_active = ?", name, OAuth2, true).Get(loginSource)
+ if !has || err != nil {
+ return nil, err
+ }
+
+ return loginSource, nil
+}
--- /dev/null
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package login
+
+import (
+ "crypto/sha256"
+ "encoding/base64"
+ "fmt"
+ "net/url"
+ "strings"
+
+ "code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/modules/secret"
+ "code.gitea.io/gitea/modules/timeutil"
+ "code.gitea.io/gitea/modules/util"
+
+ uuid "github.com/google/uuid"
+ "golang.org/x/crypto/bcrypt"
+ "xorm.io/xorm"
+)
+
+// OAuth2Application represents an OAuth2 client (RFC 6749)
+type OAuth2Application struct {
+ ID int64 `xorm:"pk autoincr"`
+ UID int64 `xorm:"INDEX"`
+ Name string
+ ClientID string `xorm:"unique"`
+ ClientSecret string
+ RedirectURIs []string `xorm:"redirect_uris JSON TEXT"`
+ CreatedUnix timeutil.TimeStamp `xorm:"INDEX created"`
+ UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated"`
+}
+
+func init() {
+ db.RegisterModel(new(OAuth2Application))
+ db.RegisterModel(new(OAuth2AuthorizationCode))
+ db.RegisterModel(new(OAuth2Grant))
+}
+
+// TableName sets the table name to `oauth2_application`
+func (app *OAuth2Application) TableName() string {
+ return "oauth2_application"
+}
+
+// PrimaryRedirectURI returns the first redirect uri or an empty string if empty
+func (app *OAuth2Application) PrimaryRedirectURI() string {
+ if len(app.RedirectURIs) == 0 {
+ return ""
+ }
+ return app.RedirectURIs[0]
+}
+
+// ContainsRedirectURI checks if redirectURI is allowed for app
+func (app *OAuth2Application) ContainsRedirectURI(redirectURI string) bool {
+ return util.IsStringInSlice(redirectURI, app.RedirectURIs, true)
+}
+
+// GenerateClientSecret will generate the client secret and returns the plaintext and saves the hash at the database
+func (app *OAuth2Application) GenerateClientSecret() (string, error) {
+ clientSecret, err := secret.New()
+ if err != nil {
+ return "", err
+ }
+ hashedSecret, err := bcrypt.GenerateFromPassword([]byte(clientSecret), bcrypt.DefaultCost)
+ if err != nil {
+ return "", err
+ }
+ app.ClientSecret = string(hashedSecret)
+ if _, err := db.GetEngine(db.DefaultContext).ID(app.ID).Cols("client_secret").Update(app); err != nil {
+ return "", err
+ }
+ return clientSecret, nil
+}
+
+// ValidateClientSecret validates the given secret by the hash saved in database
+func (app *OAuth2Application) ValidateClientSecret(secret []byte) bool {
+ return bcrypt.CompareHashAndPassword([]byte(app.ClientSecret), secret) == nil
+}
+
+// GetGrantByUserID returns a OAuth2Grant by its user and application ID
+func (app *OAuth2Application) GetGrantByUserID(userID int64) (*OAuth2Grant, error) {
+ return app.getGrantByUserID(db.GetEngine(db.DefaultContext), userID)
+}
+
+func (app *OAuth2Application) getGrantByUserID(e db.Engine, userID int64) (grant *OAuth2Grant, err error) {
+ grant = new(OAuth2Grant)
+ if has, err := e.Where("user_id = ? AND application_id = ?", userID, app.ID).Get(grant); err != nil {
+ return nil, err
+ } else if !has {
+ return nil, nil
+ }
+ return grant, nil
+}
+
+// CreateGrant generates a grant for an user
+func (app *OAuth2Application) CreateGrant(userID int64, scope string) (*OAuth2Grant, error) {
+ return app.createGrant(db.GetEngine(db.DefaultContext), userID, scope)
+}
+
+func (app *OAuth2Application) createGrant(e db.Engine, userID int64, scope string) (*OAuth2Grant, error) {
+ grant := &OAuth2Grant{
+ ApplicationID: app.ID,
+ UserID: userID,
+ Scope: scope,
+ }
+ _, err := e.Insert(grant)
+ if err != nil {
+ return nil, err
+ }
+ return grant, nil
+}
+
+// GetOAuth2ApplicationByClientID returns the oauth2 application with the given client_id. Returns an error if not found.
+func GetOAuth2ApplicationByClientID(clientID string) (app *OAuth2Application, err error) {
+ return getOAuth2ApplicationByClientID(db.GetEngine(db.DefaultContext), clientID)
+}
+
+func getOAuth2ApplicationByClientID(e db.Engine, clientID string) (app *OAuth2Application, err error) {
+ app = new(OAuth2Application)
+ has, err := e.Where("client_id = ?", clientID).Get(app)
+ if !has {
+ return nil, ErrOAuthClientIDInvalid{ClientID: clientID}
+ }
+ return
+}
+
+// GetOAuth2ApplicationByID returns the oauth2 application with the given id. Returns an error if not found.
+func GetOAuth2ApplicationByID(id int64) (app *OAuth2Application, err error) {
+ return getOAuth2ApplicationByID(db.GetEngine(db.DefaultContext), id)
+}
+
+func getOAuth2ApplicationByID(e db.Engine, id int64) (app *OAuth2Application, err error) {
+ app = new(OAuth2Application)
+ has, err := e.ID(id).Get(app)
+ if err != nil {
+ return nil, err
+ }
+ if !has {
+ return nil, ErrOAuthApplicationNotFound{ID: id}
+ }
+ return app, nil
+}
+
+// GetOAuth2ApplicationsByUserID returns all oauth2 applications owned by the user
+func GetOAuth2ApplicationsByUserID(userID int64) (apps []*OAuth2Application, err error) {
+ return getOAuth2ApplicationsByUserID(db.GetEngine(db.DefaultContext), userID)
+}
+
+func getOAuth2ApplicationsByUserID(e db.Engine, userID int64) (apps []*OAuth2Application, err error) {
+ apps = make([]*OAuth2Application, 0)
+ err = e.Where("uid = ?", userID).Find(&apps)
+ return
+}
+
+// CreateOAuth2ApplicationOptions holds options to create an oauth2 application
+type CreateOAuth2ApplicationOptions struct {
+ Name string
+ UserID int64
+ RedirectURIs []string
+}
+
+// CreateOAuth2Application inserts a new oauth2 application
+func CreateOAuth2Application(opts CreateOAuth2ApplicationOptions) (*OAuth2Application, error) {
+ return createOAuth2Application(db.GetEngine(db.DefaultContext), opts)
+}
+
+func createOAuth2Application(e db.Engine, opts CreateOAuth2ApplicationOptions) (*OAuth2Application, error) {
+ clientID := uuid.New().String()
+ app := &OAuth2Application{
+ UID: opts.UserID,
+ Name: opts.Name,
+ ClientID: clientID,
+ RedirectURIs: opts.RedirectURIs,
+ }
+ if _, err := e.Insert(app); err != nil {
+ return nil, err
+ }
+ return app, nil
+}
+
+// UpdateOAuth2ApplicationOptions holds options to update an oauth2 application
+type UpdateOAuth2ApplicationOptions struct {
+ ID int64
+ Name string
+ UserID int64
+ RedirectURIs []string
+}
+
+// UpdateOAuth2Application updates an oauth2 application
+func UpdateOAuth2Application(opts UpdateOAuth2ApplicationOptions) (*OAuth2Application, error) {
+ sess := db.NewSession(db.DefaultContext)
+ if err := sess.Begin(); err != nil {
+ return nil, err
+ }
+ defer sess.Close()
+
+ app, err := getOAuth2ApplicationByID(sess, opts.ID)
+ if err != nil {
+ return nil, err
+ }
+ if app.UID != opts.UserID {
+ return nil, fmt.Errorf("UID mismatch")
+ }
+
+ app.Name = opts.Name
+ app.RedirectURIs = opts.RedirectURIs
+
+ if err = updateOAuth2Application(sess, app); err != nil {
+ return nil, err
+ }
+ app.ClientSecret = ""
+
+ return app, sess.Commit()
+}
+
+func updateOAuth2Application(e db.Engine, app *OAuth2Application) error {
+ if _, err := e.ID(app.ID).Update(app); err != nil {
+ return err
+ }
+ return nil
+}
+
+func deleteOAuth2Application(sess *xorm.Session, id, userid int64) error {
+ if deleted, err := sess.Delete(&OAuth2Application{ID: id, UID: userid}); err != nil {
+ return err
+ } else if deleted == 0 {
+ return ErrOAuthApplicationNotFound{ID: id}
+ }
+ codes := make([]*OAuth2AuthorizationCode, 0)
+ // delete correlating auth codes
+ if err := sess.Join("INNER", "oauth2_grant",
+ "oauth2_authorization_code.grant_id = oauth2_grant.id AND oauth2_grant.application_id = ?", id).Find(&codes); err != nil {
+ return err
+ }
+ codeIDs := make([]int64, 0)
+ for _, grant := range codes {
+ codeIDs = append(codeIDs, grant.ID)
+ }
+
+ if _, err := sess.In("id", codeIDs).Delete(new(OAuth2AuthorizationCode)); err != nil {
+ return err
+ }
+
+ if _, err := sess.Where("application_id = ?", id).Delete(new(OAuth2Grant)); err != nil {
+ return err
+ }
+ return nil
+}
+
+// DeleteOAuth2Application deletes the application with the given id and the grants and auth codes related to it. It checks if the userid was the creator of the app.
+func DeleteOAuth2Application(id, userid int64) error {
+ sess := db.NewSession(db.DefaultContext)
+ defer sess.Close()
+ if err := sess.Begin(); err != nil {
+ return err
+ }
+ if err := deleteOAuth2Application(sess, id, userid); err != nil {
+ return err
+ }
+ return sess.Commit()
+}
+
+// ListOAuth2Applications returns a list of oauth2 applications belongs to given user.
+func ListOAuth2Applications(uid int64, listOptions db.ListOptions) ([]*OAuth2Application, int64, error) {
+ sess := db.GetEngine(db.DefaultContext).
+ Where("uid=?", uid).
+ Desc("id")
+
+ if listOptions.Page != 0 {
+ sess = db.SetSessionPagination(sess, &listOptions)
+
+ apps := make([]*OAuth2Application, 0, listOptions.PageSize)
+ total, err := sess.FindAndCount(&apps)
+ return apps, total, err
+ }
+
+ apps := make([]*OAuth2Application, 0, 5)
+ total, err := sess.FindAndCount(&apps)
+ return apps, total, err
+}
+
+//////////////////////////////////////////////////////
+
+// OAuth2AuthorizationCode is a code to obtain an access token in combination with the client secret once. It has a limited lifetime.
+type OAuth2AuthorizationCode struct {
+ ID int64 `xorm:"pk autoincr"`
+ Grant *OAuth2Grant `xorm:"-"`
+ GrantID int64
+ Code string `xorm:"INDEX unique"`
+ CodeChallenge string
+ CodeChallengeMethod string
+ RedirectURI string
+ ValidUntil timeutil.TimeStamp `xorm:"index"`
+}
+
+// TableName sets the table name to `oauth2_authorization_code`
+func (code *OAuth2AuthorizationCode) TableName() string {
+ return "oauth2_authorization_code"
+}
+
+// GenerateRedirectURI generates a redirect URI for a successful authorization request. State will be used if not empty.
+func (code *OAuth2AuthorizationCode) GenerateRedirectURI(state string) (redirect *url.URL, err error) {
+ if redirect, err = url.Parse(code.RedirectURI); err != nil {
+ return
+ }
+ q := redirect.Query()
+ if state != "" {
+ q.Set("state", state)
+ }
+ q.Set("code", code.Code)
+ redirect.RawQuery = q.Encode()
+ return
+}
+
+// Invalidate deletes the auth code from the database to invalidate this code
+func (code *OAuth2AuthorizationCode) Invalidate() error {
+ return code.invalidate(db.GetEngine(db.DefaultContext))
+}
+
+func (code *OAuth2AuthorizationCode) invalidate(e db.Engine) error {
+ _, err := e.Delete(code)
+ return err
+}
+
+// ValidateCodeChallenge validates the given verifier against the saved code challenge. This is part of the PKCE implementation.
+func (code *OAuth2AuthorizationCode) ValidateCodeChallenge(verifier string) bool {
+ return code.validateCodeChallenge(verifier)
+}
+
+func (code *OAuth2AuthorizationCode) validateCodeChallenge(verifier string) bool {
+ switch code.CodeChallengeMethod {
+ case "S256":
+ // base64url(SHA256(verifier)) see https://tools.ietf.org/html/rfc7636#section-4.6
+ h := sha256.Sum256([]byte(verifier))
+ hashedVerifier := base64.RawURLEncoding.EncodeToString(h[:])
+ return hashedVerifier == code.CodeChallenge
+ case "plain":
+ return verifier == code.CodeChallenge
+ case "":
+ return true
+ default:
+ // unsupported method -> return false
+ return false
+ }
+}
+
+// GetOAuth2AuthorizationByCode returns an authorization by its code
+func GetOAuth2AuthorizationByCode(code string) (*OAuth2AuthorizationCode, error) {
+ return getOAuth2AuthorizationByCode(db.GetEngine(db.DefaultContext), code)
+}
+
+func getOAuth2AuthorizationByCode(e db.Engine, code string) (auth *OAuth2AuthorizationCode, err error) {
+ auth = new(OAuth2AuthorizationCode)
+ if has, err := e.Where("code = ?", code).Get(auth); err != nil {
+ return nil, err
+ } else if !has {
+ return nil, nil
+ }
+ auth.Grant = new(OAuth2Grant)
+ if has, err := e.ID(auth.GrantID).Get(auth.Grant); err != nil {
+ return nil, err
+ } else if !has {
+ return nil, nil
+ }
+ return auth, nil
+}
+
+//////////////////////////////////////////////////////
+
+// OAuth2Grant represents the permission of an user for a specific application to access resources
+type OAuth2Grant struct {
+ ID int64 `xorm:"pk autoincr"`
+ UserID int64 `xorm:"INDEX unique(user_application)"`
+ Application *OAuth2Application `xorm:"-"`
+ ApplicationID int64 `xorm:"INDEX unique(user_application)"`
+ Counter int64 `xorm:"NOT NULL DEFAULT 1"`
+ Scope string `xorm:"TEXT"`
+ Nonce string `xorm:"TEXT"`
+ CreatedUnix timeutil.TimeStamp `xorm:"created"`
+ UpdatedUnix timeutil.TimeStamp `xorm:"updated"`
+}
+
+// TableName sets the table name to `oauth2_grant`
+func (grant *OAuth2Grant) TableName() string {
+ return "oauth2_grant"
+}
+
+// GenerateNewAuthorizationCode generates a new authorization code for a grant and saves it to the database
+func (grant *OAuth2Grant) GenerateNewAuthorizationCode(redirectURI, codeChallenge, codeChallengeMethod string) (*OAuth2AuthorizationCode, error) {
+ return grant.generateNewAuthorizationCode(db.GetEngine(db.DefaultContext), redirectURI, codeChallenge, codeChallengeMethod)
+}
+
+func (grant *OAuth2Grant) generateNewAuthorizationCode(e db.Engine, redirectURI, codeChallenge, codeChallengeMethod string) (code *OAuth2AuthorizationCode, err error) {
+ var codeSecret string
+ if codeSecret, err = secret.New(); err != nil {
+ return &OAuth2AuthorizationCode{}, err
+ }
+ code = &OAuth2AuthorizationCode{
+ Grant: grant,
+ GrantID: grant.ID,
+ RedirectURI: redirectURI,
+ Code: codeSecret,
+ CodeChallenge: codeChallenge,
+ CodeChallengeMethod: codeChallengeMethod,
+ }
+ if _, err := e.Insert(code); err != nil {
+ return nil, err
+ }
+ return code, nil
+}
+
+// IncreaseCounter increases the counter and updates the grant
+func (grant *OAuth2Grant) IncreaseCounter() error {
+ return grant.increaseCount(db.GetEngine(db.DefaultContext))
+}
+
+func (grant *OAuth2Grant) increaseCount(e db.Engine) error {
+ _, err := e.ID(grant.ID).Incr("counter").Update(new(OAuth2Grant))
+ if err != nil {
+ return err
+ }
+ updatedGrant, err := getOAuth2GrantByID(e, grant.ID)
+ if err != nil {
+ return err
+ }
+ grant.Counter = updatedGrant.Counter
+ return nil
+}
+
+// ScopeContains returns true if the grant scope contains the specified scope
+func (grant *OAuth2Grant) ScopeContains(scope string) bool {
+ for _, currentScope := range strings.Split(grant.Scope, " ") {
+ if scope == currentScope {
+ return true
+ }
+ }
+ return false
+}
+
+// SetNonce updates the current nonce value of a grant
+func (grant *OAuth2Grant) SetNonce(nonce string) error {
+ return grant.setNonce(db.GetEngine(db.DefaultContext), nonce)
+}
+
+func (grant *OAuth2Grant) setNonce(e db.Engine, nonce string) error {
+ grant.Nonce = nonce
+ _, err := e.ID(grant.ID).Cols("nonce").Update(grant)
+ if err != nil {
+ return err
+ }
+ return nil
+}
+
+// GetOAuth2GrantByID returns the grant with the given ID
+func GetOAuth2GrantByID(id int64) (*OAuth2Grant, error) {
+ return getOAuth2GrantByID(db.GetEngine(db.DefaultContext), id)
+}
+
+func getOAuth2GrantByID(e db.Engine, id int64) (grant *OAuth2Grant, err error) {
+ grant = new(OAuth2Grant)
+ if has, err := e.ID(id).Get(grant); err != nil {
+ return nil, err
+ } else if !has {
+ return nil, nil
+ }
+ return
+}
+
+// GetOAuth2GrantsByUserID lists all grants of a certain user
+func GetOAuth2GrantsByUserID(uid int64) ([]*OAuth2Grant, error) {
+ return getOAuth2GrantsByUserID(db.GetEngine(db.DefaultContext), uid)
+}
+
+func getOAuth2GrantsByUserID(e db.Engine, uid int64) ([]*OAuth2Grant, error) {
+ type joinedOAuth2Grant struct {
+ Grant *OAuth2Grant `xorm:"extends"`
+ Application *OAuth2Application `xorm:"extends"`
+ }
+ var results *xorm.Rows
+ var err error
+ if results, err = e.
+ Table("oauth2_grant").
+ Where("user_id = ?", uid).
+ Join("INNER", "oauth2_application", "application_id = oauth2_application.id").
+ Rows(new(joinedOAuth2Grant)); err != nil {
+ return nil, err
+ }
+ defer results.Close()
+ grants := make([]*OAuth2Grant, 0)
+ for results.Next() {
+ joinedGrant := new(joinedOAuth2Grant)
+ if err := results.Scan(joinedGrant); err != nil {
+ return nil, err
+ }
+ joinedGrant.Grant.Application = joinedGrant.Application
+ grants = append(grants, joinedGrant.Grant)
+ }
+ return grants, nil
+}
+
+// RevokeOAuth2Grant deletes the grant with grantID and userID
+func RevokeOAuth2Grant(grantID, userID int64) error {
+ return revokeOAuth2Grant(db.GetEngine(db.DefaultContext), grantID, userID)
+}
+
+func revokeOAuth2Grant(e db.Engine, grantID, userID int64) error {
+ _, err := e.Delete(&OAuth2Grant{ID: grantID, UserID: userID})
+ return err
+}
--- /dev/null
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package login
+
+import (
+ "testing"
+
+ "code.gitea.io/gitea/models/db"
+
+ "github.com/stretchr/testify/assert"
+)
+
+//////////////////// Application
+
+func TestOAuth2Application_GenerateClientSecret(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
+ secret, err := app.GenerateClientSecret()
+ assert.NoError(t, err)
+ assert.True(t, len(secret) > 0)
+ db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1, ClientSecret: app.ClientSecret})
+}
+
+func BenchmarkOAuth2Application_GenerateClientSecret(b *testing.B) {
+ assert.NoError(b, db.PrepareTestDatabase())
+ app := db.AssertExistsAndLoadBean(b, &OAuth2Application{ID: 1}).(*OAuth2Application)
+ for i := 0; i < b.N; i++ {
+ _, _ = app.GenerateClientSecret()
+ }
+}
+
+func TestOAuth2Application_ContainsRedirectURI(t *testing.T) {
+ app := &OAuth2Application{
+ RedirectURIs: []string{"a", "b", "c"},
+ }
+ assert.True(t, app.ContainsRedirectURI("a"))
+ assert.True(t, app.ContainsRedirectURI("b"))
+ assert.True(t, app.ContainsRedirectURI("c"))
+ assert.False(t, app.ContainsRedirectURI("d"))
+}
+
+func TestOAuth2Application_ValidateClientSecret(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
+ secret, err := app.GenerateClientSecret()
+ assert.NoError(t, err)
+ assert.True(t, app.ValidateClientSecret([]byte(secret)))
+ assert.False(t, app.ValidateClientSecret([]byte("fewijfowejgfiowjeoifew")))
+}
+
+func TestGetOAuth2ApplicationByClientID(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ app, err := GetOAuth2ApplicationByClientID("da7da3ba-9a13-4167-856f-3899de0b0138")
+ assert.NoError(t, err)
+ assert.Equal(t, "da7da3ba-9a13-4167-856f-3899de0b0138", app.ClientID)
+
+ app, err = GetOAuth2ApplicationByClientID("invalid client id")
+ assert.Error(t, err)
+ assert.Nil(t, app)
+}
+
+func TestCreateOAuth2Application(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ app, err := CreateOAuth2Application(CreateOAuth2ApplicationOptions{Name: "newapp", UserID: 1})
+ assert.NoError(t, err)
+ assert.Equal(t, "newapp", app.Name)
+ assert.Len(t, app.ClientID, 36)
+ db.AssertExistsAndLoadBean(t, &OAuth2Application{Name: "newapp"})
+}
+
+func TestOAuth2Application_TableName(t *testing.T) {
+ assert.Equal(t, "oauth2_application", new(OAuth2Application).TableName())
+}
+
+func TestOAuth2Application_GetGrantByUserID(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
+ grant, err := app.GetGrantByUserID(1)
+ assert.NoError(t, err)
+ assert.Equal(t, int64(1), grant.UserID)
+
+ grant, err = app.GetGrantByUserID(34923458)
+ assert.NoError(t, err)
+ assert.Nil(t, grant)
+}
+
+func TestOAuth2Application_CreateGrant(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
+ grant, err := app.CreateGrant(2, "")
+ assert.NoError(t, err)
+ assert.NotNil(t, grant)
+ assert.Equal(t, int64(2), grant.UserID)
+ assert.Equal(t, int64(1), grant.ApplicationID)
+ assert.Equal(t, "", grant.Scope)
+}
+
+//////////////////// Grant
+
+func TestGetOAuth2GrantByID(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ grant, err := GetOAuth2GrantByID(1)
+ assert.NoError(t, err)
+ assert.Equal(t, int64(1), grant.ID)
+
+ grant, err = GetOAuth2GrantByID(34923458)
+ assert.NoError(t, err)
+ assert.Nil(t, grant)
+}
+
+func TestOAuth2Grant_IncreaseCounter(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ grant := db.AssertExistsAndLoadBean(t, &OAuth2Grant{ID: 1, Counter: 1}).(*OAuth2Grant)
+ assert.NoError(t, grant.IncreaseCounter())
+ assert.Equal(t, int64(2), grant.Counter)
+ db.AssertExistsAndLoadBean(t, &OAuth2Grant{ID: 1, Counter: 2})
+}
+
+func TestOAuth2Grant_ScopeContains(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ grant := db.AssertExistsAndLoadBean(t, &OAuth2Grant{ID: 1, Scope: "openid profile"}).(*OAuth2Grant)
+ assert.True(t, grant.ScopeContains("openid"))
+ assert.True(t, grant.ScopeContains("profile"))
+ assert.False(t, grant.ScopeContains("profil"))
+ assert.False(t, grant.ScopeContains("profile2"))
+}
+
+func TestOAuth2Grant_GenerateNewAuthorizationCode(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ grant := db.AssertExistsAndLoadBean(t, &OAuth2Grant{ID: 1}).(*OAuth2Grant)
+ code, err := grant.GenerateNewAuthorizationCode("https://example2.com/callback", "CjvyTLSdR47G5zYenDA-eDWW4lRrO8yvjcWwbD_deOg", "S256")
+ assert.NoError(t, err)
+ assert.NotNil(t, code)
+ assert.True(t, len(code.Code) > 32) // secret length > 32
+}
+
+func TestOAuth2Grant_TableName(t *testing.T) {
+ assert.Equal(t, "oauth2_grant", new(OAuth2Grant).TableName())
+}
+
+func TestGetOAuth2GrantsByUserID(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ result, err := GetOAuth2GrantsByUserID(1)
+ assert.NoError(t, err)
+ assert.Len(t, result, 1)
+ assert.Equal(t, int64(1), result[0].ID)
+ assert.Equal(t, result[0].ApplicationID, result[0].Application.ID)
+
+ result, err = GetOAuth2GrantsByUserID(34134)
+ assert.NoError(t, err)
+ assert.Empty(t, result)
+}
+
+func TestRevokeOAuth2Grant(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ assert.NoError(t, RevokeOAuth2Grant(1, 1))
+ db.AssertNotExistsBean(t, &OAuth2Grant{ID: 1, UserID: 1})
+}
+
+//////////////////// Authorization Code
+
+func TestGetOAuth2AuthorizationByCode(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ code, err := GetOAuth2AuthorizationByCode("authcode")
+ assert.NoError(t, err)
+ assert.NotNil(t, code)
+ assert.Equal(t, "authcode", code.Code)
+ assert.Equal(t, int64(1), code.ID)
+
+ code, err = GetOAuth2AuthorizationByCode("does not exist")
+ assert.NoError(t, err)
+ assert.Nil(t, code)
+}
+
+func TestOAuth2AuthorizationCode_ValidateCodeChallenge(t *testing.T) {
+ // test plain
+ code := &OAuth2AuthorizationCode{
+ CodeChallengeMethod: "plain",
+ CodeChallenge: "test123",
+ }
+ assert.True(t, code.ValidateCodeChallenge("test123"))
+ assert.False(t, code.ValidateCodeChallenge("ierwgjoergjio"))
+
+ // test S256
+ code = &OAuth2AuthorizationCode{
+ CodeChallengeMethod: "S256",
+ CodeChallenge: "CjvyTLSdR47G5zYenDA-eDWW4lRrO8yvjcWwbD_deOg",
+ }
+ assert.True(t, code.ValidateCodeChallenge("N1Zo9-8Rfwhkt68r1r29ty8YwIraXR8eh_1Qwxg7yQXsonBt"))
+ assert.False(t, code.ValidateCodeChallenge("wiogjerogorewngoenrgoiuenorg"))
+
+ // test unknown
+ code = &OAuth2AuthorizationCode{
+ CodeChallengeMethod: "monkey",
+ CodeChallenge: "foiwgjioriogeiogjerger",
+ }
+ assert.False(t, code.ValidateCodeChallenge("foiwgjioriogeiogjerger"))
+
+ // test no code challenge
+ code = &OAuth2AuthorizationCode{
+ CodeChallengeMethod: "",
+ CodeChallenge: "foierjiogerogerg",
+ }
+ assert.True(t, code.ValidateCodeChallenge(""))
+}
+
+func TestOAuth2AuthorizationCode_GenerateRedirectURI(t *testing.T) {
+ code := &OAuth2AuthorizationCode{
+ RedirectURI: "https://example.com/callback",
+ Code: "thecode",
+ }
+
+ redirect, err := code.GenerateRedirectURI("thestate")
+ assert.NoError(t, err)
+ assert.Equal(t, "https://example.com/callback?code=thecode&state=thestate", redirect.String())
+
+ redirect, err = code.GenerateRedirectURI("")
+ assert.NoError(t, err)
+ assert.Equal(t, "https://example.com/callback?code=thecode", redirect.String())
+}
+
+func TestOAuth2AuthorizationCode_Invalidate(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ code := db.AssertExistsAndLoadBean(t, &OAuth2AuthorizationCode{Code: "authcode"}).(*OAuth2AuthorizationCode)
+ assert.NoError(t, code.Invalidate())
+ db.AssertNotExistsBean(t, &OAuth2AuthorizationCode{Code: "authcode"})
+}
+
+func TestOAuth2AuthorizationCode_TableName(t *testing.T) {
+ assert.Equal(t, "oauth2_authorization_code", new(OAuth2AuthorizationCode).TableName())
+}
--- /dev/null
+// Copyright 2014 The Gogs Authors. All rights reserved.
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package login
+
+import (
+ "fmt"
+ "reflect"
+ "strconv"
+
+ "code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/modules/log"
+ "code.gitea.io/gitea/modules/timeutil"
+
+ "xorm.io/xorm"
+ "xorm.io/xorm/convert"
+)
+
+// Type represents an login type.
+type Type int
+
+// Note: new type must append to the end of list to maintain compatibility.
+const (
+ NoType Type = iota
+ Plain // 1
+ LDAP // 2
+ SMTP // 3
+ PAM // 4
+ DLDAP // 5
+ OAuth2 // 6
+ SSPI // 7
+)
+
+// String returns the string name of the LoginType
+func (typ Type) String() string {
+ return Names[typ]
+}
+
+// Int returns the int value of the LoginType
+func (typ Type) Int() int {
+ return int(typ)
+}
+
+// Names contains the name of LoginType values.
+var Names = map[Type]string{
+ LDAP: "LDAP (via BindDN)",
+ DLDAP: "LDAP (simple auth)", // Via direct bind
+ SMTP: "SMTP",
+ PAM: "PAM",
+ OAuth2: "OAuth2",
+ SSPI: "SPNEGO with SSPI",
+}
+
+// Config represents login config as far as the db is concerned
+type Config interface {
+ convert.Conversion
+}
+
+// SkipVerifiable configurations provide a IsSkipVerify to check if SkipVerify is set
+type SkipVerifiable interface {
+ IsSkipVerify() bool
+}
+
+// HasTLSer configurations provide a HasTLS to check if TLS can be enabled
+type HasTLSer interface {
+ HasTLS() bool
+}
+
+// UseTLSer configurations provide a HasTLS to check if TLS is enabled
+type UseTLSer interface {
+ UseTLS() bool
+}
+
+// SSHKeyProvider configurations provide ProvidesSSHKeys to check if they provide SSHKeys
+type SSHKeyProvider interface {
+ ProvidesSSHKeys() bool
+}
+
+// RegisterableSource configurations provide RegisterSource which needs to be run on creation
+type RegisterableSource interface {
+ RegisterSource() error
+ UnregisterSource() error
+}
+
+// SourceSettable configurations can have their loginSource set on them
+type SourceSettable interface {
+ SetLoginSource(*Source)
+}
+
+// RegisterTypeConfig register a config for a provided type
+func RegisterTypeConfig(typ Type, exemplar Config) {
+ if reflect.TypeOf(exemplar).Kind() == reflect.Ptr {
+ // Pointer:
+ registeredConfigs[typ] = func() Config {
+ return reflect.New(reflect.ValueOf(exemplar).Elem().Type()).Interface().(Config)
+ }
+ return
+ }
+
+ // Not a Pointer
+ registeredConfigs[typ] = func() Config {
+ return reflect.New(reflect.TypeOf(exemplar)).Elem().Interface().(Config)
+ }
+}
+
+var registeredConfigs = map[Type]func() Config{}
+
+// Source represents an external way for authorizing users.
+type Source struct {
+ ID int64 `xorm:"pk autoincr"`
+ Type Type
+ Name string `xorm:"UNIQUE"`
+ IsActive bool `xorm:"INDEX NOT NULL DEFAULT false"`
+ IsSyncEnabled bool `xorm:"INDEX NOT NULL DEFAULT false"`
+ Cfg convert.Conversion `xorm:"TEXT"`
+
+ CreatedUnix timeutil.TimeStamp `xorm:"INDEX created"`
+ UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated"`
+}
+
+// TableName xorm will read the table name from this method
+func (Source) TableName() string {
+ return "login_source"
+}
+
+func init() {
+ db.RegisterModel(new(Source))
+}
+
+// Cell2Int64 converts a xorm.Cell type to int64,
+// and handles possible irregular cases.
+func Cell2Int64(val xorm.Cell) int64 {
+ switch (*val).(type) {
+ case []uint8:
+ log.Trace("Cell2Int64 ([]uint8): %v", *val)
+
+ v, _ := strconv.ParseInt(string((*val).([]uint8)), 10, 64)
+ return v
+ }
+ return (*val).(int64)
+}
+
+// BeforeSet is invoked from XORM before setting the value of a field of this object.
+func (source *Source) BeforeSet(colName string, val xorm.Cell) {
+ if colName == "type" {
+ typ := Type(Cell2Int64(val))
+ constructor, ok := registeredConfigs[typ]
+ if !ok {
+ return
+ }
+ source.Cfg = constructor()
+ if settable, ok := source.Cfg.(SourceSettable); ok {
+ settable.SetLoginSource(source)
+ }
+ }
+}
+
+// TypeName return name of this login source type.
+func (source *Source) TypeName() string {
+ return Names[source.Type]
+}
+
+// IsLDAP returns true of this source is of the LDAP type.
+func (source *Source) IsLDAP() bool {
+ return source.Type == LDAP
+}
+
+// IsDLDAP returns true of this source is of the DLDAP type.
+func (source *Source) IsDLDAP() bool {
+ return source.Type == DLDAP
+}
+
+// IsSMTP returns true of this source is of the SMTP type.
+func (source *Source) IsSMTP() bool {
+ return source.Type == SMTP
+}
+
+// IsPAM returns true of this source is of the PAM type.
+func (source *Source) IsPAM() bool {
+ return source.Type == PAM
+}
+
+// IsOAuth2 returns true of this source is of the OAuth2 type.
+func (source *Source) IsOAuth2() bool {
+ return source.Type == OAuth2
+}
+
+// IsSSPI returns true of this source is of the SSPI type.
+func (source *Source) IsSSPI() bool {
+ return source.Type == SSPI
+}
+
+// HasTLS returns true of this source supports TLS.
+func (source *Source) HasTLS() bool {
+ hasTLSer, ok := source.Cfg.(HasTLSer)
+ return ok && hasTLSer.HasTLS()
+}
+
+// UseTLS returns true of this source is configured to use TLS.
+func (source *Source) UseTLS() bool {
+ useTLSer, ok := source.Cfg.(UseTLSer)
+ return ok && useTLSer.UseTLS()
+}
+
+// SkipVerify returns true if this source is configured to skip SSL
+// verification.
+func (source *Source) SkipVerify() bool {
+ skipVerifiable, ok := source.Cfg.(SkipVerifiable)
+ return ok && skipVerifiable.IsSkipVerify()
+}
+
+// CreateSource inserts a LoginSource in the DB if not already
+// existing with the given name.
+func CreateSource(source *Source) error {
+ has, err := db.GetEngine(db.DefaultContext).Where("name=?", source.Name).Exist(new(Source))
+ if err != nil {
+ return err
+ } else if has {
+ return ErrSourceAlreadyExist{source.Name}
+ }
+ // Synchronization is only available with LDAP for now
+ if !source.IsLDAP() {
+ source.IsSyncEnabled = false
+ }
+
+ _, err = db.GetEngine(db.DefaultContext).Insert(source)
+ if err != nil {
+ return err
+ }
+
+ if !source.IsActive {
+ return nil
+ }
+
+ if settable, ok := source.Cfg.(SourceSettable); ok {
+ settable.SetLoginSource(source)
+ }
+
+ registerableSource, ok := source.Cfg.(RegisterableSource)
+ if !ok {
+ return nil
+ }
+
+ err = registerableSource.RegisterSource()
+ if err != nil {
+ // remove the LoginSource in case of errors while registering configuration
+ if _, err := db.GetEngine(db.DefaultContext).Delete(source); err != nil {
+ log.Error("CreateSource: Error while wrapOpenIDConnectInitializeError: %v", err)
+ }
+ }
+ return err
+}
+
+// Sources returns a slice of all login sources found in DB.
+func Sources() ([]*Source, error) {
+ auths := make([]*Source, 0, 6)
+ return auths, db.GetEngine(db.DefaultContext).Find(&auths)
+}
+
+// SourcesByType returns all sources of the specified type
+func SourcesByType(loginType Type) ([]*Source, error) {
+ sources := make([]*Source, 0, 1)
+ if err := db.GetEngine(db.DefaultContext).Where("type = ?", loginType).Find(&sources); err != nil {
+ return nil, err
+ }
+ return sources, nil
+}
+
+// AllActiveSources returns all active sources
+func AllActiveSources() ([]*Source, error) {
+ sources := make([]*Source, 0, 5)
+ if err := db.GetEngine(db.DefaultContext).Where("is_active = ?", true).Find(&sources); err != nil {
+ return nil, err
+ }
+ return sources, nil
+}
+
+// ActiveSources returns all active sources of the specified type
+func ActiveSources(tp Type) ([]*Source, error) {
+ sources := make([]*Source, 0, 1)
+ if err := db.GetEngine(db.DefaultContext).Where("is_active = ? and type = ?", true, tp).Find(&sources); err != nil {
+ return nil, err
+ }
+ return sources, nil
+}
+
+// IsSSPIEnabled returns true if there is at least one activated login
+// source of type LoginSSPI
+func IsSSPIEnabled() bool {
+ if !db.HasEngine {
+ return false
+ }
+ sources, err := ActiveSources(SSPI)
+ if err != nil {
+ log.Error("ActiveSources: %v", err)
+ return false
+ }
+ return len(sources) > 0
+}
+
+// GetSourceByID returns login source by given ID.
+func GetSourceByID(id int64) (*Source, error) {
+ source := new(Source)
+ if id == 0 {
+ source.Cfg = registeredConfigs[NoType]()
+ // Set this source to active
+ // FIXME: allow disabling of db based password authentication in future
+ source.IsActive = true
+ return source, nil
+ }
+
+ has, err := db.GetEngine(db.DefaultContext).ID(id).Get(source)
+ if err != nil {
+ return nil, err
+ } else if !has {
+ return nil, ErrSourceNotExist{id}
+ }
+ return source, nil
+}
+
+// UpdateSource updates a Source record in DB.
+func UpdateSource(source *Source) error {
+ var originalLoginSource *Source
+ if source.IsOAuth2() {
+ // keep track of the original values so we can restore in case of errors while registering OAuth2 providers
+ var err error
+ if originalLoginSource, err = GetSourceByID(source.ID); err != nil {
+ return err
+ }
+ }
+
+ _, err := db.GetEngine(db.DefaultContext).ID(source.ID).AllCols().Update(source)
+ if err != nil {
+ return err
+ }
+
+ if !source.IsActive {
+ return nil
+ }
+
+ if settable, ok := source.Cfg.(SourceSettable); ok {
+ settable.SetLoginSource(source)
+ }
+
+ registerableSource, ok := source.Cfg.(RegisterableSource)
+ if !ok {
+ return nil
+ }
+
+ err = registerableSource.RegisterSource()
+ if err != nil {
+ // restore original values since we cannot update the provider it self
+ if _, err := db.GetEngine(db.DefaultContext).ID(source.ID).AllCols().Update(originalLoginSource); err != nil {
+ log.Error("UpdateSource: Error while wrapOpenIDConnectInitializeError: %v", err)
+ }
+ }
+ return err
+}
+
+// CountSources returns number of login sources.
+func CountSources() int64 {
+ count, _ := db.GetEngine(db.DefaultContext).Count(new(Source))
+ return count
+}
+
+// ErrSourceNotExist represents a "SourceNotExist" kind of error.
+type ErrSourceNotExist struct {
+ ID int64
+}
+
+// IsErrSourceNotExist checks if an error is a ErrSourceNotExist.
+func IsErrSourceNotExist(err error) bool {
+ _, ok := err.(ErrSourceNotExist)
+ return ok
+}
+
+func (err ErrSourceNotExist) Error() string {
+ return fmt.Sprintf("login source does not exist [id: %d]", err.ID)
+}
+
+// ErrSourceAlreadyExist represents a "SourceAlreadyExist" kind of error.
+type ErrSourceAlreadyExist struct {
+ Name string
+}
+
+// IsErrSourceAlreadyExist checks if an error is a ErrSourceAlreadyExist.
+func IsErrSourceAlreadyExist(err error) bool {
+ _, ok := err.(ErrSourceAlreadyExist)
+ return ok
+}
+
+func (err ErrSourceAlreadyExist) Error() string {
+ return fmt.Sprintf("login source already exists [name: %s]", err.Name)
+}
+
+// ErrSourceInUse represents a "SourceInUse" kind of error.
+type ErrSourceInUse struct {
+ ID int64
+}
+
+// IsErrSourceInUse checks if an error is a ErrSourceInUse.
+func IsErrSourceInUse(err error) bool {
+ _, ok := err.(ErrSourceInUse)
+ return ok
+}
+
+func (err ErrSourceInUse) Error() string {
+ return fmt.Sprintf("login source is still used by some users [id: %d]", err.ID)
+}
--- /dev/null
+// Copyright 2019 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package login
+
+import (
+ "strings"
+ "testing"
+
+ "code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/modules/json"
+
+ "github.com/stretchr/testify/assert"
+ "xorm.io/xorm/schemas"
+)
+
+type TestSource struct {
+ Provider string
+ ClientID string
+ ClientSecret string
+ OpenIDConnectAutoDiscoveryURL string
+ IconURL string
+}
+
+// FromDB fills up a LDAPConfig from serialized format.
+func (source *TestSource) FromDB(bs []byte) error {
+ return json.Unmarshal(bs, &source)
+}
+
+// ToDB exports a LDAPConfig to a serialized format.
+func (source *TestSource) ToDB() ([]byte, error) {
+ return json.Marshal(source)
+}
+
+func TestDumpLoginSource(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+
+ loginSourceSchema, err := db.TableInfo(new(Source))
+ assert.NoError(t, err)
+
+ RegisterTypeConfig(OAuth2, new(TestSource))
+
+ CreateSource(&Source{
+ Type: OAuth2,
+ Name: "TestSource",
+ IsActive: false,
+ Cfg: &TestSource{
+ Provider: "ConvertibleSourceName",
+ ClientID: "42",
+ },
+ })
+
+ sb := new(strings.Builder)
+
+ db.DumpTables([]*schemas.Table{loginSourceSchema}, sb)
+
+ assert.Contains(t, sb.String(), `"Provider":"ConvertibleSourceName"`)
+}
+++ /dev/null
-// Copyright 2014 The Gogs Authors. All rights reserved.
-// Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package models
-
-import (
- "reflect"
- "strconv"
-
- "code.gitea.io/gitea/models/db"
- "code.gitea.io/gitea/modules/log"
- "code.gitea.io/gitea/modules/timeutil"
-
- "xorm.io/xorm"
- "xorm.io/xorm/convert"
-)
-
-// LoginType represents an login type.
-type LoginType int
-
-// Note: new type must append to the end of list to maintain compatibility.
-const (
- LoginNoType LoginType = iota
- LoginPlain // 1
- LoginLDAP // 2
- LoginSMTP // 3
- LoginPAM // 4
- LoginDLDAP // 5
- LoginOAuth2 // 6
- LoginSSPI // 7
-)
-
-// String returns the string name of the LoginType
-func (typ LoginType) String() string {
- return LoginNames[typ]
-}
-
-// Int returns the int value of the LoginType
-func (typ LoginType) Int() int {
- return int(typ)
-}
-
-// LoginNames contains the name of LoginType values.
-var LoginNames = map[LoginType]string{
- LoginLDAP: "LDAP (via BindDN)",
- LoginDLDAP: "LDAP (simple auth)", // Via direct bind
- LoginSMTP: "SMTP",
- LoginPAM: "PAM",
- LoginOAuth2: "OAuth2",
- LoginSSPI: "SPNEGO with SSPI",
-}
-
-// LoginConfig represents login config as far as the db is concerned
-type LoginConfig interface {
- convert.Conversion
-}
-
-// SkipVerifiable configurations provide a IsSkipVerify to check if SkipVerify is set
-type SkipVerifiable interface {
- IsSkipVerify() bool
-}
-
-// HasTLSer configurations provide a HasTLS to check if TLS can be enabled
-type HasTLSer interface {
- HasTLS() bool
-}
-
-// UseTLSer configurations provide a HasTLS to check if TLS is enabled
-type UseTLSer interface {
- UseTLS() bool
-}
-
-// SSHKeyProvider configurations provide ProvidesSSHKeys to check if they provide SSHKeys
-type SSHKeyProvider interface {
- ProvidesSSHKeys() bool
-}
-
-// RegisterableSource configurations provide RegisterSource which needs to be run on creation
-type RegisterableSource interface {
- RegisterSource() error
- UnregisterSource() error
-}
-
-// LoginSourceSettable configurations can have their loginSource set on them
-type LoginSourceSettable interface {
- SetLoginSource(*LoginSource)
-}
-
-// RegisterLoginTypeConfig register a config for a provided type
-func RegisterLoginTypeConfig(typ LoginType, exemplar LoginConfig) {
- if reflect.TypeOf(exemplar).Kind() == reflect.Ptr {
- // Pointer:
- registeredLoginConfigs[typ] = func() LoginConfig {
- return reflect.New(reflect.ValueOf(exemplar).Elem().Type()).Interface().(LoginConfig)
- }
- return
- }
-
- // Not a Pointer
- registeredLoginConfigs[typ] = func() LoginConfig {
- return reflect.New(reflect.TypeOf(exemplar)).Elem().Interface().(LoginConfig)
- }
-}
-
-var registeredLoginConfigs = map[LoginType]func() LoginConfig{}
-
-// LoginSource represents an external way for authorizing users.
-type LoginSource struct {
- ID int64 `xorm:"pk autoincr"`
- Type LoginType
- Name string `xorm:"UNIQUE"`
- IsActive bool `xorm:"INDEX NOT NULL DEFAULT false"`
- IsSyncEnabled bool `xorm:"INDEX NOT NULL DEFAULT false"`
- Cfg convert.Conversion `xorm:"TEXT"`
-
- CreatedUnix timeutil.TimeStamp `xorm:"INDEX created"`
- UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated"`
-}
-
-func init() {
- db.RegisterModel(new(LoginSource))
-}
-
-// Cell2Int64 converts a xorm.Cell type to int64,
-// and handles possible irregular cases.
-func Cell2Int64(val xorm.Cell) int64 {
- switch (*val).(type) {
- case []uint8:
- log.Trace("Cell2Int64 ([]uint8): %v", *val)
-
- v, _ := strconv.ParseInt(string((*val).([]uint8)), 10, 64)
- return v
- }
- return (*val).(int64)
-}
-
-// BeforeSet is invoked from XORM before setting the value of a field of this object.
-func (source *LoginSource) BeforeSet(colName string, val xorm.Cell) {
- if colName == "type" {
- typ := LoginType(Cell2Int64(val))
- constructor, ok := registeredLoginConfigs[typ]
- if !ok {
- return
- }
- source.Cfg = constructor()
- if settable, ok := source.Cfg.(LoginSourceSettable); ok {
- settable.SetLoginSource(source)
- }
- }
-}
-
-// TypeName return name of this login source type.
-func (source *LoginSource) TypeName() string {
- return LoginNames[source.Type]
-}
-
-// IsLDAP returns true of this source is of the LDAP type.
-func (source *LoginSource) IsLDAP() bool {
- return source.Type == LoginLDAP
-}
-
-// IsDLDAP returns true of this source is of the DLDAP type.
-func (source *LoginSource) IsDLDAP() bool {
- return source.Type == LoginDLDAP
-}
-
-// IsSMTP returns true of this source is of the SMTP type.
-func (source *LoginSource) IsSMTP() bool {
- return source.Type == LoginSMTP
-}
-
-// IsPAM returns true of this source is of the PAM type.
-func (source *LoginSource) IsPAM() bool {
- return source.Type == LoginPAM
-}
-
-// IsOAuth2 returns true of this source is of the OAuth2 type.
-func (source *LoginSource) IsOAuth2() bool {
- return source.Type == LoginOAuth2
-}
-
-// IsSSPI returns true of this source is of the SSPI type.
-func (source *LoginSource) IsSSPI() bool {
- return source.Type == LoginSSPI
-}
-
-// HasTLS returns true of this source supports TLS.
-func (source *LoginSource) HasTLS() bool {
- hasTLSer, ok := source.Cfg.(HasTLSer)
- return ok && hasTLSer.HasTLS()
-}
-
-// UseTLS returns true of this source is configured to use TLS.
-func (source *LoginSource) UseTLS() bool {
- useTLSer, ok := source.Cfg.(UseTLSer)
- return ok && useTLSer.UseTLS()
-}
-
-// SkipVerify returns true if this source is configured to skip SSL
-// verification.
-func (source *LoginSource) SkipVerify() bool {
- skipVerifiable, ok := source.Cfg.(SkipVerifiable)
- return ok && skipVerifiable.IsSkipVerify()
-}
-
-// CreateLoginSource inserts a LoginSource in the DB if not already
-// existing with the given name.
-func CreateLoginSource(source *LoginSource) error {
- has, err := db.GetEngine(db.DefaultContext).Where("name=?", source.Name).Exist(new(LoginSource))
- if err != nil {
- return err
- } else if has {
- return ErrLoginSourceAlreadyExist{source.Name}
- }
- // Synchronization is only available with LDAP for now
- if !source.IsLDAP() {
- source.IsSyncEnabled = false
- }
-
- _, err = db.GetEngine(db.DefaultContext).Insert(source)
- if err != nil {
- return err
- }
-
- if !source.IsActive {
- return nil
- }
-
- if settable, ok := source.Cfg.(LoginSourceSettable); ok {
- settable.SetLoginSource(source)
- }
-
- registerableSource, ok := source.Cfg.(RegisterableSource)
- if !ok {
- return nil
- }
-
- err = registerableSource.RegisterSource()
- if err != nil {
- // remove the LoginSource in case of errors while registering configuration
- if _, err := db.GetEngine(db.DefaultContext).Delete(source); err != nil {
- log.Error("CreateLoginSource: Error while wrapOpenIDConnectInitializeError: %v", err)
- }
- }
- return err
-}
-
-// LoginSources returns a slice of all login sources found in DB.
-func LoginSources() ([]*LoginSource, error) {
- auths := make([]*LoginSource, 0, 6)
- return auths, db.GetEngine(db.DefaultContext).Find(&auths)
-}
-
-// LoginSourcesByType returns all sources of the specified type
-func LoginSourcesByType(loginType LoginType) ([]*LoginSource, error) {
- sources := make([]*LoginSource, 0, 1)
- if err := db.GetEngine(db.DefaultContext).Where("type = ?", loginType).Find(&sources); err != nil {
- return nil, err
- }
- return sources, nil
-}
-
-// AllActiveLoginSources returns all active sources
-func AllActiveLoginSources() ([]*LoginSource, error) {
- sources := make([]*LoginSource, 0, 5)
- if err := db.GetEngine(db.DefaultContext).Where("is_active = ?", true).Find(&sources); err != nil {
- return nil, err
- }
- return sources, nil
-}
-
-// ActiveLoginSources returns all active sources of the specified type
-func ActiveLoginSources(loginType LoginType) ([]*LoginSource, error) {
- sources := make([]*LoginSource, 0, 1)
- if err := db.GetEngine(db.DefaultContext).Where("is_active = ? and type = ?", true, loginType).Find(&sources); err != nil {
- return nil, err
- }
- return sources, nil
-}
-
-// IsSSPIEnabled returns true if there is at least one activated login
-// source of type LoginSSPI
-func IsSSPIEnabled() bool {
- if !db.HasEngine {
- return false
- }
- sources, err := ActiveLoginSources(LoginSSPI)
- if err != nil {
- log.Error("ActiveLoginSources: %v", err)
- return false
- }
- return len(sources) > 0
-}
-
-// GetLoginSourceByID returns login source by given ID.
-func GetLoginSourceByID(id int64) (*LoginSource, error) {
- source := new(LoginSource)
- if id == 0 {
- source.Cfg = registeredLoginConfigs[LoginNoType]()
- // Set this source to active
- // FIXME: allow disabling of db based password authentication in future
- source.IsActive = true
- return source, nil
- }
-
- has, err := db.GetEngine(db.DefaultContext).ID(id).Get(source)
- if err != nil {
- return nil, err
- } else if !has {
- return nil, ErrLoginSourceNotExist{id}
- }
- return source, nil
-}
-
-// UpdateSource updates a LoginSource record in DB.
-func UpdateSource(source *LoginSource) error {
- var originalLoginSource *LoginSource
- if source.IsOAuth2() {
- // keep track of the original values so we can restore in case of errors while registering OAuth2 providers
- var err error
- if originalLoginSource, err = GetLoginSourceByID(source.ID); err != nil {
- return err
- }
- }
-
- _, err := db.GetEngine(db.DefaultContext).ID(source.ID).AllCols().Update(source)
- if err != nil {
- return err
- }
-
- if !source.IsActive {
- return nil
- }
-
- if settable, ok := source.Cfg.(LoginSourceSettable); ok {
- settable.SetLoginSource(source)
- }
-
- registerableSource, ok := source.Cfg.(RegisterableSource)
- if !ok {
- return nil
- }
-
- err = registerableSource.RegisterSource()
- if err != nil {
- // restore original values since we cannot update the provider it self
- if _, err := db.GetEngine(db.DefaultContext).ID(source.ID).AllCols().Update(originalLoginSource); err != nil {
- log.Error("UpdateSource: Error while wrapOpenIDConnectInitializeError: %v", err)
- }
- }
- return err
-}
-
-// DeleteSource deletes a LoginSource record in DB.
-func DeleteSource(source *LoginSource) error {
- count, err := db.GetEngine(db.DefaultContext).Count(&User{LoginSource: source.ID})
- if err != nil {
- return err
- } else if count > 0 {
- return ErrLoginSourceInUse{source.ID}
- }
-
- count, err = db.GetEngine(db.DefaultContext).Count(&ExternalLoginUser{LoginSourceID: source.ID})
- if err != nil {
- return err
- } else if count > 0 {
- return ErrLoginSourceInUse{source.ID}
- }
-
- if registerableSource, ok := source.Cfg.(RegisterableSource); ok {
- if err := registerableSource.UnregisterSource(); err != nil {
- return err
- }
- }
-
- _, err = db.GetEngine(db.DefaultContext).ID(source.ID).Delete(new(LoginSource))
- return err
-}
-
-// CountLoginSources returns number of login sources.
-func CountLoginSources() int64 {
- count, _ := db.GetEngine(db.DefaultContext).Count(new(LoginSource))
- return count
-}
+++ /dev/null
-// Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package models
-
-import (
- "strings"
- "testing"
-
- "code.gitea.io/gitea/models/db"
- "code.gitea.io/gitea/modules/json"
-
- "github.com/stretchr/testify/assert"
- "xorm.io/xorm/schemas"
-)
-
-type TestSource struct {
- Provider string
- ClientID string
- ClientSecret string
- OpenIDConnectAutoDiscoveryURL string
- IconURL string
-}
-
-// FromDB fills up a LDAPConfig from serialized format.
-func (source *TestSource) FromDB(bs []byte) error {
- return json.Unmarshal(bs, &source)
-}
-
-// ToDB exports a LDAPConfig to a serialized format.
-func (source *TestSource) ToDB() ([]byte, error) {
- return json.Marshal(source)
-}
-
-func TestDumpLoginSource(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
-
- loginSourceSchema, err := db.TableInfo(new(LoginSource))
- assert.NoError(t, err)
-
- RegisterLoginTypeConfig(LoginOAuth2, new(TestSource))
-
- CreateLoginSource(&LoginSource{
- Type: LoginOAuth2,
- Name: "TestSource",
- IsActive: false,
- Cfg: &TestSource{
- Provider: "ConvertibleSourceName",
- ClientID: "42",
- },
- })
-
- sb := new(strings.Builder)
-
- db.DumpTables([]*schemas.Table{loginSourceSchema}, sb)
-
- assert.Contains(t, sb.String(), `"Provider":"ConvertibleSourceName"`)
-}
if _, err := os.Stat(fixturesDir); err == nil {
t.Logf("initializing fixtures from: %s", fixturesDir)
- if err := db.InitFixtures(fixturesDir, x); err != nil {
+ if err := db.InitFixtures(
+ db.FixturesOptions{
+ Dir: fixturesDir,
+ }, x); err != nil {
t.Errorf("error whilst initializing fixtures from %s: %v", fixturesDir, err)
return x, deferFn
}
// FindNotificationOptions represent the filters for notifications. If an ID is 0 it will be ignored.
type FindNotificationOptions struct {
- ListOptions
+ db.ListOptions
UserID int64
RepoID int64
IssueID int64
func (opts *FindNotificationOptions) ToSession(e db.Engine) *xorm.Session {
sess := e.Where(opts.ToCond())
if opts.Page != 0 {
- sess = setSessionPagination(sess, opts)
+ sess = db.SetSessionPagination(sess, opts)
}
return sess
}
+++ /dev/null
-// Copyright 2017 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package models
-
-import "code.gitea.io/gitea/models/db"
-
-// GetActiveOAuth2ProviderLoginSources returns all actived LoginOAuth2 sources
-func GetActiveOAuth2ProviderLoginSources() ([]*LoginSource, error) {
- sources := make([]*LoginSource, 0, 1)
- if err := db.GetEngine(db.DefaultContext).Where("is_active = ? and type = ?", true, LoginOAuth2).Find(&sources); err != nil {
- return nil, err
- }
- return sources, nil
-}
-
-// GetActiveOAuth2LoginSourceByName returns a OAuth2 LoginSource based on the given name
-func GetActiveOAuth2LoginSourceByName(name string) (*LoginSource, error) {
- loginSource := new(LoginSource)
- has, err := db.GetEngine(db.DefaultContext).Where("name = ? and type = ? and is_active = ?", name, LoginOAuth2, true).Get(loginSource)
- if !has || err != nil {
- return nil, err
- }
-
- return loginSource, nil
-}
+++ /dev/null
-// Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package models
-
-import (
- "crypto/sha256"
- "encoding/base64"
- "fmt"
- "net/url"
- "strings"
-
- "code.gitea.io/gitea/models/db"
- "code.gitea.io/gitea/modules/secret"
- "code.gitea.io/gitea/modules/timeutil"
- "code.gitea.io/gitea/modules/util"
-
- uuid "github.com/google/uuid"
- "golang.org/x/crypto/bcrypt"
- "xorm.io/xorm"
-)
-
-// OAuth2Application represents an OAuth2 client (RFC 6749)
-type OAuth2Application struct {
- ID int64 `xorm:"pk autoincr"`
- UID int64 `xorm:"INDEX"`
- User *User `xorm:"-"`
-
- Name string
-
- ClientID string `xorm:"unique"`
- ClientSecret string
-
- RedirectURIs []string `xorm:"redirect_uris JSON TEXT"`
-
- CreatedUnix timeutil.TimeStamp `xorm:"INDEX created"`
- UpdatedUnix timeutil.TimeStamp `xorm:"INDEX updated"`
-}
-
-func init() {
- db.RegisterModel(new(OAuth2Application))
- db.RegisterModel(new(OAuth2AuthorizationCode))
- db.RegisterModel(new(OAuth2Grant))
-}
-
-// TableName sets the table name to `oauth2_application`
-func (app *OAuth2Application) TableName() string {
- return "oauth2_application"
-}
-
-// PrimaryRedirectURI returns the first redirect uri or an empty string if empty
-func (app *OAuth2Application) PrimaryRedirectURI() string {
- if len(app.RedirectURIs) == 0 {
- return ""
- }
- return app.RedirectURIs[0]
-}
-
-// LoadUser will load User by UID
-func (app *OAuth2Application) LoadUser() (err error) {
- if app.User == nil {
- app.User, err = GetUserByID(app.UID)
- }
- return
-}
-
-// ContainsRedirectURI checks if redirectURI is allowed for app
-func (app *OAuth2Application) ContainsRedirectURI(redirectURI string) bool {
- return util.IsStringInSlice(redirectURI, app.RedirectURIs, true)
-}
-
-// GenerateClientSecret will generate the client secret and returns the plaintext and saves the hash at the database
-func (app *OAuth2Application) GenerateClientSecret() (string, error) {
- clientSecret, err := secret.New()
- if err != nil {
- return "", err
- }
- hashedSecret, err := bcrypt.GenerateFromPassword([]byte(clientSecret), bcrypt.DefaultCost)
- if err != nil {
- return "", err
- }
- app.ClientSecret = string(hashedSecret)
- if _, err := db.GetEngine(db.DefaultContext).ID(app.ID).Cols("client_secret").Update(app); err != nil {
- return "", err
- }
- return clientSecret, nil
-}
-
-// ValidateClientSecret validates the given secret by the hash saved in database
-func (app *OAuth2Application) ValidateClientSecret(secret []byte) bool {
- return bcrypt.CompareHashAndPassword([]byte(app.ClientSecret), secret) == nil
-}
-
-// GetGrantByUserID returns a OAuth2Grant by its user and application ID
-func (app *OAuth2Application) GetGrantByUserID(userID int64) (*OAuth2Grant, error) {
- return app.getGrantByUserID(db.GetEngine(db.DefaultContext), userID)
-}
-
-func (app *OAuth2Application) getGrantByUserID(e db.Engine, userID int64) (grant *OAuth2Grant, err error) {
- grant = new(OAuth2Grant)
- if has, err := e.Where("user_id = ? AND application_id = ?", userID, app.ID).Get(grant); err != nil {
- return nil, err
- } else if !has {
- return nil, nil
- }
- return grant, nil
-}
-
-// CreateGrant generates a grant for an user
-func (app *OAuth2Application) CreateGrant(userID int64, scope string) (*OAuth2Grant, error) {
- return app.createGrant(db.GetEngine(db.DefaultContext), userID, scope)
-}
-
-func (app *OAuth2Application) createGrant(e db.Engine, userID int64, scope string) (*OAuth2Grant, error) {
- grant := &OAuth2Grant{
- ApplicationID: app.ID,
- UserID: userID,
- Scope: scope,
- }
- _, err := e.Insert(grant)
- if err != nil {
- return nil, err
- }
- return grant, nil
-}
-
-// GetOAuth2ApplicationByClientID returns the oauth2 application with the given client_id. Returns an error if not found.
-func GetOAuth2ApplicationByClientID(clientID string) (app *OAuth2Application, err error) {
- return getOAuth2ApplicationByClientID(db.GetEngine(db.DefaultContext), clientID)
-}
-
-func getOAuth2ApplicationByClientID(e db.Engine, clientID string) (app *OAuth2Application, err error) {
- app = new(OAuth2Application)
- has, err := e.Where("client_id = ?", clientID).Get(app)
- if !has {
- return nil, ErrOAuthClientIDInvalid{ClientID: clientID}
- }
- return
-}
-
-// GetOAuth2ApplicationByID returns the oauth2 application with the given id. Returns an error if not found.
-func GetOAuth2ApplicationByID(id int64) (app *OAuth2Application, err error) {
- return getOAuth2ApplicationByID(db.GetEngine(db.DefaultContext), id)
-}
-
-func getOAuth2ApplicationByID(e db.Engine, id int64) (app *OAuth2Application, err error) {
- app = new(OAuth2Application)
- has, err := e.ID(id).Get(app)
- if err != nil {
- return nil, err
- }
- if !has {
- return nil, ErrOAuthApplicationNotFound{ID: id}
- }
- return app, nil
-}
-
-// GetOAuth2ApplicationsByUserID returns all oauth2 applications owned by the user
-func GetOAuth2ApplicationsByUserID(userID int64) (apps []*OAuth2Application, err error) {
- return getOAuth2ApplicationsByUserID(db.GetEngine(db.DefaultContext), userID)
-}
-
-func getOAuth2ApplicationsByUserID(e db.Engine, userID int64) (apps []*OAuth2Application, err error) {
- apps = make([]*OAuth2Application, 0)
- err = e.Where("uid = ?", userID).Find(&apps)
- return
-}
-
-// CreateOAuth2ApplicationOptions holds options to create an oauth2 application
-type CreateOAuth2ApplicationOptions struct {
- Name string
- UserID int64
- RedirectURIs []string
-}
-
-// CreateOAuth2Application inserts a new oauth2 application
-func CreateOAuth2Application(opts CreateOAuth2ApplicationOptions) (*OAuth2Application, error) {
- return createOAuth2Application(db.GetEngine(db.DefaultContext), opts)
-}
-
-func createOAuth2Application(e db.Engine, opts CreateOAuth2ApplicationOptions) (*OAuth2Application, error) {
- clientID := uuid.New().String()
- app := &OAuth2Application{
- UID: opts.UserID,
- Name: opts.Name,
- ClientID: clientID,
- RedirectURIs: opts.RedirectURIs,
- }
- if _, err := e.Insert(app); err != nil {
- return nil, err
- }
- return app, nil
-}
-
-// UpdateOAuth2ApplicationOptions holds options to update an oauth2 application
-type UpdateOAuth2ApplicationOptions struct {
- ID int64
- Name string
- UserID int64
- RedirectURIs []string
-}
-
-// UpdateOAuth2Application updates an oauth2 application
-func UpdateOAuth2Application(opts UpdateOAuth2ApplicationOptions) (*OAuth2Application, error) {
- sess := db.NewSession(db.DefaultContext)
- if err := sess.Begin(); err != nil {
- return nil, err
- }
- defer sess.Close()
-
- app, err := getOAuth2ApplicationByID(sess, opts.ID)
- if err != nil {
- return nil, err
- }
- if app.UID != opts.UserID {
- return nil, fmt.Errorf("UID mismatch")
- }
-
- app.Name = opts.Name
- app.RedirectURIs = opts.RedirectURIs
-
- if err = updateOAuth2Application(sess, app); err != nil {
- return nil, err
- }
- app.ClientSecret = ""
-
- return app, sess.Commit()
-}
-
-func updateOAuth2Application(e db.Engine, app *OAuth2Application) error {
- if _, err := e.ID(app.ID).Update(app); err != nil {
- return err
- }
- return nil
-}
-
-func deleteOAuth2Application(sess *xorm.Session, id, userid int64) error {
- if deleted, err := sess.Delete(&OAuth2Application{ID: id, UID: userid}); err != nil {
- return err
- } else if deleted == 0 {
- return ErrOAuthApplicationNotFound{ID: id}
- }
- codes := make([]*OAuth2AuthorizationCode, 0)
- // delete correlating auth codes
- if err := sess.Join("INNER", "oauth2_grant",
- "oauth2_authorization_code.grant_id = oauth2_grant.id AND oauth2_grant.application_id = ?", id).Find(&codes); err != nil {
- return err
- }
- codeIDs := make([]int64, 0)
- for _, grant := range codes {
- codeIDs = append(codeIDs, grant.ID)
- }
-
- if _, err := sess.In("id", codeIDs).Delete(new(OAuth2AuthorizationCode)); err != nil {
- return err
- }
-
- if _, err := sess.Where("application_id = ?", id).Delete(new(OAuth2Grant)); err != nil {
- return err
- }
- return nil
-}
-
-// DeleteOAuth2Application deletes the application with the given id and the grants and auth codes related to it. It checks if the userid was the creator of the app.
-func DeleteOAuth2Application(id, userid int64) error {
- sess := db.NewSession(db.DefaultContext)
- defer sess.Close()
- if err := sess.Begin(); err != nil {
- return err
- }
- if err := deleteOAuth2Application(sess, id, userid); err != nil {
- return err
- }
- return sess.Commit()
-}
-
-// ListOAuth2Applications returns a list of oauth2 applications belongs to given user.
-func ListOAuth2Applications(uid int64, listOptions ListOptions) ([]*OAuth2Application, int64, error) {
- sess := db.GetEngine(db.DefaultContext).
- Where("uid=?", uid).
- Desc("id")
-
- if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
-
- apps := make([]*OAuth2Application, 0, listOptions.PageSize)
- total, err := sess.FindAndCount(&apps)
- return apps, total, err
- }
-
- apps := make([]*OAuth2Application, 0, 5)
- total, err := sess.FindAndCount(&apps)
- return apps, total, err
-}
-
-//////////////////////////////////////////////////////
-
-// OAuth2AuthorizationCode is a code to obtain an access token in combination with the client secret once. It has a limited lifetime.
-type OAuth2AuthorizationCode struct {
- ID int64 `xorm:"pk autoincr"`
- Grant *OAuth2Grant `xorm:"-"`
- GrantID int64
- Code string `xorm:"INDEX unique"`
- CodeChallenge string
- CodeChallengeMethod string
- RedirectURI string
- ValidUntil timeutil.TimeStamp `xorm:"index"`
-}
-
-// TableName sets the table name to `oauth2_authorization_code`
-func (code *OAuth2AuthorizationCode) TableName() string {
- return "oauth2_authorization_code"
-}
-
-// GenerateRedirectURI generates a redirect URI for a successful authorization request. State will be used if not empty.
-func (code *OAuth2AuthorizationCode) GenerateRedirectURI(state string) (redirect *url.URL, err error) {
- if redirect, err = url.Parse(code.RedirectURI); err != nil {
- return
- }
- q := redirect.Query()
- if state != "" {
- q.Set("state", state)
- }
- q.Set("code", code.Code)
- redirect.RawQuery = q.Encode()
- return
-}
-
-// Invalidate deletes the auth code from the database to invalidate this code
-func (code *OAuth2AuthorizationCode) Invalidate() error {
- return code.invalidate(db.GetEngine(db.DefaultContext))
-}
-
-func (code *OAuth2AuthorizationCode) invalidate(e db.Engine) error {
- _, err := e.Delete(code)
- return err
-}
-
-// ValidateCodeChallenge validates the given verifier against the saved code challenge. This is part of the PKCE implementation.
-func (code *OAuth2AuthorizationCode) ValidateCodeChallenge(verifier string) bool {
- return code.validateCodeChallenge(verifier)
-}
-
-func (code *OAuth2AuthorizationCode) validateCodeChallenge(verifier string) bool {
- switch code.CodeChallengeMethod {
- case "S256":
- // base64url(SHA256(verifier)) see https://tools.ietf.org/html/rfc7636#section-4.6
- h := sha256.Sum256([]byte(verifier))
- hashedVerifier := base64.RawURLEncoding.EncodeToString(h[:])
- return hashedVerifier == code.CodeChallenge
- case "plain":
- return verifier == code.CodeChallenge
- case "":
- return true
- default:
- // unsupported method -> return false
- return false
- }
-}
-
-// GetOAuth2AuthorizationByCode returns an authorization by its code
-func GetOAuth2AuthorizationByCode(code string) (*OAuth2AuthorizationCode, error) {
- return getOAuth2AuthorizationByCode(db.GetEngine(db.DefaultContext), code)
-}
-
-func getOAuth2AuthorizationByCode(e db.Engine, code string) (auth *OAuth2AuthorizationCode, err error) {
- auth = new(OAuth2AuthorizationCode)
- if has, err := e.Where("code = ?", code).Get(auth); err != nil {
- return nil, err
- } else if !has {
- return nil, nil
- }
- auth.Grant = new(OAuth2Grant)
- if has, err := e.ID(auth.GrantID).Get(auth.Grant); err != nil {
- return nil, err
- } else if !has {
- return nil, nil
- }
- return auth, nil
-}
-
-//////////////////////////////////////////////////////
-
-// OAuth2Grant represents the permission of an user for a specific application to access resources
-type OAuth2Grant struct {
- ID int64 `xorm:"pk autoincr"`
- UserID int64 `xorm:"INDEX unique(user_application)"`
- Application *OAuth2Application `xorm:"-"`
- ApplicationID int64 `xorm:"INDEX unique(user_application)"`
- Counter int64 `xorm:"NOT NULL DEFAULT 1"`
- Scope string `xorm:"TEXT"`
- Nonce string `xorm:"TEXT"`
- CreatedUnix timeutil.TimeStamp `xorm:"created"`
- UpdatedUnix timeutil.TimeStamp `xorm:"updated"`
-}
-
-// TableName sets the table name to `oauth2_grant`
-func (grant *OAuth2Grant) TableName() string {
- return "oauth2_grant"
-}
-
-// GenerateNewAuthorizationCode generates a new authorization code for a grant and saves it to the database
-func (grant *OAuth2Grant) GenerateNewAuthorizationCode(redirectURI, codeChallenge, codeChallengeMethod string) (*OAuth2AuthorizationCode, error) {
- return grant.generateNewAuthorizationCode(db.GetEngine(db.DefaultContext), redirectURI, codeChallenge, codeChallengeMethod)
-}
-
-func (grant *OAuth2Grant) generateNewAuthorizationCode(e db.Engine, redirectURI, codeChallenge, codeChallengeMethod string) (code *OAuth2AuthorizationCode, err error) {
- var codeSecret string
- if codeSecret, err = secret.New(); err != nil {
- return &OAuth2AuthorizationCode{}, err
- }
- code = &OAuth2AuthorizationCode{
- Grant: grant,
- GrantID: grant.ID,
- RedirectURI: redirectURI,
- Code: codeSecret,
- CodeChallenge: codeChallenge,
- CodeChallengeMethod: codeChallengeMethod,
- }
- if _, err := e.Insert(code); err != nil {
- return nil, err
- }
- return code, nil
-}
-
-// IncreaseCounter increases the counter and updates the grant
-func (grant *OAuth2Grant) IncreaseCounter() error {
- return grant.increaseCount(db.GetEngine(db.DefaultContext))
-}
-
-func (grant *OAuth2Grant) increaseCount(e db.Engine) error {
- _, err := e.ID(grant.ID).Incr("counter").Update(new(OAuth2Grant))
- if err != nil {
- return err
- }
- updatedGrant, err := getOAuth2GrantByID(e, grant.ID)
- if err != nil {
- return err
- }
- grant.Counter = updatedGrant.Counter
- return nil
-}
-
-// ScopeContains returns true if the grant scope contains the specified scope
-func (grant *OAuth2Grant) ScopeContains(scope string) bool {
- for _, currentScope := range strings.Split(grant.Scope, " ") {
- if scope == currentScope {
- return true
- }
- }
- return false
-}
-
-// SetNonce updates the current nonce value of a grant
-func (grant *OAuth2Grant) SetNonce(nonce string) error {
- return grant.setNonce(db.GetEngine(db.DefaultContext), nonce)
-}
-
-func (grant *OAuth2Grant) setNonce(e db.Engine, nonce string) error {
- grant.Nonce = nonce
- _, err := e.ID(grant.ID).Cols("nonce").Update(grant)
- if err != nil {
- return err
- }
- return nil
-}
-
-// GetOAuth2GrantByID returns the grant with the given ID
-func GetOAuth2GrantByID(id int64) (*OAuth2Grant, error) {
- return getOAuth2GrantByID(db.GetEngine(db.DefaultContext), id)
-}
-
-func getOAuth2GrantByID(e db.Engine, id int64) (grant *OAuth2Grant, err error) {
- grant = new(OAuth2Grant)
- if has, err := e.ID(id).Get(grant); err != nil {
- return nil, err
- } else if !has {
- return nil, nil
- }
- return
-}
-
-// GetOAuth2GrantsByUserID lists all grants of a certain user
-func GetOAuth2GrantsByUserID(uid int64) ([]*OAuth2Grant, error) {
- return getOAuth2GrantsByUserID(db.GetEngine(db.DefaultContext), uid)
-}
-
-func getOAuth2GrantsByUserID(e db.Engine, uid int64) ([]*OAuth2Grant, error) {
- type joinedOAuth2Grant struct {
- Grant *OAuth2Grant `xorm:"extends"`
- Application *OAuth2Application `xorm:"extends"`
- }
- var results *xorm.Rows
- var err error
- if results, err = e.
- Table("oauth2_grant").
- Where("user_id = ?", uid).
- Join("INNER", "oauth2_application", "application_id = oauth2_application.id").
- Rows(new(joinedOAuth2Grant)); err != nil {
- return nil, err
- }
- defer results.Close()
- grants := make([]*OAuth2Grant, 0)
- for results.Next() {
- joinedGrant := new(joinedOAuth2Grant)
- if err := results.Scan(joinedGrant); err != nil {
- return nil, err
- }
- joinedGrant.Grant.Application = joinedGrant.Application
- grants = append(grants, joinedGrant.Grant)
- }
- return grants, nil
-}
-
-// RevokeOAuth2Grant deletes the grant with grantID and userID
-func RevokeOAuth2Grant(grantID, userID int64) error {
- return revokeOAuth2Grant(db.GetEngine(db.DefaultContext), grantID, userID)
-}
-
-func revokeOAuth2Grant(e db.Engine, grantID, userID int64) error {
- _, err := e.Delete(&OAuth2Grant{ID: grantID, UserID: userID})
- return err
-}
+++ /dev/null
-// Copyright 2019 The Gitea Authors. All rights reserved.
-// Use of this source code is governed by a MIT-style
-// license that can be found in the LICENSE file.
-
-package models
-
-import (
- "testing"
-
- "code.gitea.io/gitea/models/db"
- "github.com/stretchr/testify/assert"
-)
-
-//////////////////// Application
-
-func TestOAuth2Application_GenerateClientSecret(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
- secret, err := app.GenerateClientSecret()
- assert.NoError(t, err)
- assert.True(t, len(secret) > 0)
- db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1, ClientSecret: app.ClientSecret})
-}
-
-func BenchmarkOAuth2Application_GenerateClientSecret(b *testing.B) {
- assert.NoError(b, db.PrepareTestDatabase())
- app := db.AssertExistsAndLoadBean(b, &OAuth2Application{ID: 1}).(*OAuth2Application)
- for i := 0; i < b.N; i++ {
- _, _ = app.GenerateClientSecret()
- }
-}
-
-func TestOAuth2Application_ContainsRedirectURI(t *testing.T) {
- app := &OAuth2Application{
- RedirectURIs: []string{"a", "b", "c"},
- }
- assert.True(t, app.ContainsRedirectURI("a"))
- assert.True(t, app.ContainsRedirectURI("b"))
- assert.True(t, app.ContainsRedirectURI("c"))
- assert.False(t, app.ContainsRedirectURI("d"))
-}
-
-func TestOAuth2Application_ValidateClientSecret(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
- secret, err := app.GenerateClientSecret()
- assert.NoError(t, err)
- assert.True(t, app.ValidateClientSecret([]byte(secret)))
- assert.False(t, app.ValidateClientSecret([]byte("fewijfowejgfiowjeoifew")))
-}
-
-func TestGetOAuth2ApplicationByClientID(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- app, err := GetOAuth2ApplicationByClientID("da7da3ba-9a13-4167-856f-3899de0b0138")
- assert.NoError(t, err)
- assert.Equal(t, "da7da3ba-9a13-4167-856f-3899de0b0138", app.ClientID)
-
- app, err = GetOAuth2ApplicationByClientID("invalid client id")
- assert.Error(t, err)
- assert.Nil(t, app)
-}
-
-func TestCreateOAuth2Application(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- app, err := CreateOAuth2Application(CreateOAuth2ApplicationOptions{Name: "newapp", UserID: 1})
- assert.NoError(t, err)
- assert.Equal(t, "newapp", app.Name)
- assert.Len(t, app.ClientID, 36)
- db.AssertExistsAndLoadBean(t, &OAuth2Application{Name: "newapp"})
-}
-
-func TestOAuth2Application_LoadUser(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
- assert.NoError(t, app.LoadUser())
- assert.NotNil(t, app.User)
-}
-
-func TestOAuth2Application_TableName(t *testing.T) {
- assert.Equal(t, "oauth2_application", new(OAuth2Application).TableName())
-}
-
-func TestOAuth2Application_GetGrantByUserID(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
- grant, err := app.GetGrantByUserID(1)
- assert.NoError(t, err)
- assert.Equal(t, int64(1), grant.UserID)
-
- grant, err = app.GetGrantByUserID(34923458)
- assert.NoError(t, err)
- assert.Nil(t, grant)
-}
-
-func TestOAuth2Application_CreateGrant(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- app := db.AssertExistsAndLoadBean(t, &OAuth2Application{ID: 1}).(*OAuth2Application)
- grant, err := app.CreateGrant(2, "")
- assert.NoError(t, err)
- assert.NotNil(t, grant)
- assert.Equal(t, int64(2), grant.UserID)
- assert.Equal(t, int64(1), grant.ApplicationID)
- assert.Equal(t, "", grant.Scope)
-}
-
-//////////////////// Grant
-
-func TestGetOAuth2GrantByID(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- grant, err := GetOAuth2GrantByID(1)
- assert.NoError(t, err)
- assert.Equal(t, int64(1), grant.ID)
-
- grant, err = GetOAuth2GrantByID(34923458)
- assert.NoError(t, err)
- assert.Nil(t, grant)
-}
-
-func TestOAuth2Grant_IncreaseCounter(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- grant := db.AssertExistsAndLoadBean(t, &OAuth2Grant{ID: 1, Counter: 1}).(*OAuth2Grant)
- assert.NoError(t, grant.IncreaseCounter())
- assert.Equal(t, int64(2), grant.Counter)
- db.AssertExistsAndLoadBean(t, &OAuth2Grant{ID: 1, Counter: 2})
-}
-
-func TestOAuth2Grant_ScopeContains(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- grant := db.AssertExistsAndLoadBean(t, &OAuth2Grant{ID: 1, Scope: "openid profile"}).(*OAuth2Grant)
- assert.True(t, grant.ScopeContains("openid"))
- assert.True(t, grant.ScopeContains("profile"))
- assert.False(t, grant.ScopeContains("profil"))
- assert.False(t, grant.ScopeContains("profile2"))
-}
-
-func TestOAuth2Grant_GenerateNewAuthorizationCode(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- grant := db.AssertExistsAndLoadBean(t, &OAuth2Grant{ID: 1}).(*OAuth2Grant)
- code, err := grant.GenerateNewAuthorizationCode("https://example2.com/callback", "CjvyTLSdR47G5zYenDA-eDWW4lRrO8yvjcWwbD_deOg", "S256")
- assert.NoError(t, err)
- assert.NotNil(t, code)
- assert.True(t, len(code.Code) > 32) // secret length > 32
-}
-
-func TestOAuth2Grant_TableName(t *testing.T) {
- assert.Equal(t, "oauth2_grant", new(OAuth2Grant).TableName())
-}
-
-func TestGetOAuth2GrantsByUserID(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- result, err := GetOAuth2GrantsByUserID(1)
- assert.NoError(t, err)
- assert.Len(t, result, 1)
- assert.Equal(t, int64(1), result[0].ID)
- assert.Equal(t, result[0].ApplicationID, result[0].Application.ID)
-
- result, err = GetOAuth2GrantsByUserID(34134)
- assert.NoError(t, err)
- assert.Empty(t, result)
-}
-
-func TestRevokeOAuth2Grant(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- assert.NoError(t, RevokeOAuth2Grant(1, 1))
- db.AssertNotExistsBean(t, &OAuth2Grant{ID: 1, UserID: 1})
-}
-
-//////////////////// Authorization Code
-
-func TestGetOAuth2AuthorizationByCode(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- code, err := GetOAuth2AuthorizationByCode("authcode")
- assert.NoError(t, err)
- assert.NotNil(t, code)
- assert.Equal(t, "authcode", code.Code)
- assert.Equal(t, int64(1), code.ID)
-
- code, err = GetOAuth2AuthorizationByCode("does not exist")
- assert.NoError(t, err)
- assert.Nil(t, code)
-}
-
-func TestOAuth2AuthorizationCode_ValidateCodeChallenge(t *testing.T) {
- // test plain
- code := &OAuth2AuthorizationCode{
- CodeChallengeMethod: "plain",
- CodeChallenge: "test123",
- }
- assert.True(t, code.ValidateCodeChallenge("test123"))
- assert.False(t, code.ValidateCodeChallenge("ierwgjoergjio"))
-
- // test S256
- code = &OAuth2AuthorizationCode{
- CodeChallengeMethod: "S256",
- CodeChallenge: "CjvyTLSdR47G5zYenDA-eDWW4lRrO8yvjcWwbD_deOg",
- }
- assert.True(t, code.ValidateCodeChallenge("N1Zo9-8Rfwhkt68r1r29ty8YwIraXR8eh_1Qwxg7yQXsonBt"))
- assert.False(t, code.ValidateCodeChallenge("wiogjerogorewngoenrgoiuenorg"))
-
- // test unknown
- code = &OAuth2AuthorizationCode{
- CodeChallengeMethod: "monkey",
- CodeChallenge: "foiwgjioriogeiogjerger",
- }
- assert.False(t, code.ValidateCodeChallenge("foiwgjioriogeiogjerger"))
-
- // test no code challenge
- code = &OAuth2AuthorizationCode{
- CodeChallengeMethod: "",
- CodeChallenge: "foierjiogerogerg",
- }
- assert.True(t, code.ValidateCodeChallenge(""))
-}
-
-func TestOAuth2AuthorizationCode_GenerateRedirectURI(t *testing.T) {
- code := &OAuth2AuthorizationCode{
- RedirectURI: "https://example.com/callback",
- Code: "thecode",
- }
-
- redirect, err := code.GenerateRedirectURI("thestate")
- assert.NoError(t, err)
- assert.Equal(t, "https://example.com/callback?code=thecode&state=thestate", redirect.String())
-
- redirect, err = code.GenerateRedirectURI("")
- assert.NoError(t, err)
- assert.Equal(t, "https://example.com/callback?code=thecode", redirect.String())
-}
-
-func TestOAuth2AuthorizationCode_Invalidate(t *testing.T) {
- assert.NoError(t, db.PrepareTestDatabase())
- code := db.AssertExistsAndLoadBean(t, &OAuth2AuthorizationCode{Code: "authcode"}).(*OAuth2AuthorizationCode)
- assert.NoError(t, code.Invalidate())
- db.AssertNotExistsBean(t, &OAuth2AuthorizationCode{Code: "authcode"})
-}
-
-func TestOAuth2AuthorizationCode_TableName(t *testing.T) {
- assert.Equal(t, "oauth2_authorization_code", new(OAuth2AuthorizationCode).TableName())
-}
// FindOrgMembersOpts represensts find org members conditions
type FindOrgMembersOpts struct {
- ListOptions
+ db.ListOptions
OrgID int64
PublicOnly bool
}
}
if opts.PageSize != 0 {
- sess = setSessionPagination(sess, opts)
+ sess = db.SetSessionPagination(sess, opts)
}
err := sess.
sess.And("is_public = ?", true)
}
if opts.ListOptions.PageSize > 0 {
- sess = setSessionPagination(sess, opts)
+ sess = db.SetSessionPagination(sess, opts)
ous := make([]*OrgUser, 0, opts.PageSize)
return ous, sess.Find(&ous)
// SearchTeamOptions holds the search options
type SearchTeamOptions struct {
- ListOptions
+ db.ListOptions
UserID int64
Keyword string
OrgID int64
// SearchMembersOptions holds the search options
type SearchMembersOptions struct {
- ListOptions
+ db.ListOptions
}
// SearchTeam search for teams. Caller is responsible to check permissions.
return t.getRepositories(db.GetEngine(db.DefaultContext))
}
- return t.getRepositories(getPaginatedSession(opts))
+ return t.getRepositories(db.GetPaginatedSession(opts))
}
func (t *Team) getMembers(e db.Engine) (err error) {
return t.getMembers(db.GetEngine(db.DefaultContext))
}
- return t.getMembers(getPaginatedSession(opts))
+ return t.getMembers(db.GetPaginatedSession(opts))
}
// AddMember adds new membership of the team to the organization,
assert.NoError(t, db.PrepareTestDatabase())
orgUsers, err := GetOrgUsersByOrgID(&FindOrgMembersOpts{
- ListOptions: ListOptions{},
+ ListOptions: db.ListOptions{},
OrgID: 3,
PublicOnly: false,
})
}
orgUsers, err = GetOrgUsersByOrgID(&FindOrgMembersOpts{
- ListOptions: ListOptions{},
+ ListOptions: db.ListOptions{},
OrgID: db.NonexistentID,
PublicOnly: false,
})
// PullRequestsOptions holds the options for PRs
type PullRequestsOptions struct {
- ListOptions
+ db.ListOptions
State string
SortType string
Labels []string
log.Error("listPullRequestStatement: %v", err)
return nil, maxResults, err
}
- findSession = setSessionPagination(findSession, opts)
+ findSession = db.SetSessionPagination(findSession, opts)
prs := make([]*PullRequest, 0, opts.PageSize)
return prs, maxResults, findSession.Find(&prs)
}
package models
import (
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
case always:
break Loop
case pubkey:
- keys, err := ListGPGKeys(u.ID, ListOptions{})
+ keys, err := ListGPGKeys(u.ID, db.ListOptions{})
if err != nil {
return false, "", nil, err
}
func TestPullRequestsNewest(t *testing.T) {
assert.NoError(t, db.PrepareTestDatabase())
prs, count, err := PullRequests(1, &PullRequestsOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
},
State: "open",
func TestPullRequestsOldest(t *testing.T) {
assert.NoError(t, db.PrepareTestDatabase())
prs, count, err := PullRequests(1, &PullRequestsOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
},
State: "open",
// FindReleasesOptions describes the conditions to Find releases
type FindReleasesOptions struct {
- ListOptions
+ db.ListOptions
IncludeDrafts bool
IncludeTags bool
IsPreRelease util.OptionalBool
Where(opts.toConds(repoID))
if opts.PageSize != 0 {
- sess = setSessionPagination(sess, &opts.ListOptions)
+ sess = db.SetSessionPagination(sess, &opts.ListOptions)
}
rels := make([]*Release, 0, opts.PageSize)
sess.Where(cond).OrderBy(opts.OrderBy.String())
repos := make([]*Repository, 0, opts.PageSize)
- return repos, count, setSessionPagination(sess, opts).Find(&repos)
+ return repos, count, db.SetSessionPagination(sess, opts).Find(&repos)
}
// GetUserMirrorRepositories returns a list of mirror repositories of given user.
}
// GetForks returns all the forks of the repository
-func (repo *Repository) GetForks(listOptions ListOptions) ([]*Repository, error) {
+func (repo *Repository) GetForks(listOptions db.ListOptions) ([]*Repository, error) {
if listOptions.Page == 0 {
forks := make([]*Repository, 0, repo.NumForks)
return forks, db.GetEngine(db.DefaultContext).Find(&forks, &Repository{ForkID: repo.ID})
}
- sess := getPaginatedSession(&listOptions)
+ sess := db.GetPaginatedSession(&listOptions)
forks := make([]*Repository, 0, listOptions.PageSize)
return forks, sess.Find(&forks, &Repository{ForkID: repo.ID})
}
return sess.Commit()
}
-func (repo *Repository) getCollaborations(e db.Engine, listOptions ListOptions) ([]*Collaboration, error) {
+func (repo *Repository) getCollaborations(e db.Engine, listOptions db.ListOptions) ([]*Collaboration, error) {
if listOptions.Page == 0 {
collaborations := make([]*Collaboration, 0, 8)
return collaborations, e.Find(&collaborations, &Collaboration{RepoID: repo.ID})
}
- e = setEnginePagination(e, &listOptions)
+ e = db.SetEnginePagination(e, &listOptions)
collaborations := make([]*Collaboration, 0, listOptions.PageSize)
return collaborations, e.Find(&collaborations, &Collaboration{RepoID: repo.ID})
Collaboration *Collaboration
}
-func (repo *Repository) getCollaborators(e db.Engine, listOptions ListOptions) ([]*Collaborator, error) {
+func (repo *Repository) getCollaborators(e db.Engine, listOptions db.ListOptions) ([]*Collaborator, error) {
collaborations, err := repo.getCollaborations(e, listOptions)
if err != nil {
return nil, fmt.Errorf("getCollaborations: %v", err)
}
// GetCollaborators returns the collaborators for a repository
-func (repo *Repository) GetCollaborators(listOptions ListOptions) ([]*Collaborator, error) {
+func (repo *Repository) GetCollaborators(listOptions db.ListOptions) ([]*Collaborator, error) {
return repo.getCollaborators(db.GetEngine(db.DefaultContext), listOptions)
}
assert.NoError(t, db.PrepareTestDatabase())
test := func(repoID int64) {
repo := db.AssertExistsAndLoadBean(t, &Repository{ID: repoID}).(*Repository)
- collaborators, err := repo.GetCollaborators(ListOptions{})
+ collaborators, err := repo.GetCollaborators(db.ListOptions{})
assert.NoError(t, err)
expectedLen, err := db.GetEngine(db.DefaultContext).Count(&Collaboration{RepoID: repoID})
assert.NoError(t, err)
// GenerateIssueLabels generates issue labels from a template repository
func GenerateIssueLabels(ctx context.Context, templateRepo, generateRepo *Repository) error {
- templateLabels, err := getLabelsByRepoID(db.GetEngine(ctx), templateRepo.ID, "", ListOptions{})
+ templateLabels, err := getLabelsByRepoID(db.GetEngine(ctx), templateRepo.ID, "", db.ListOptions{})
if err != nil {
return err
}
// SearchRepoOptions holds the search options
type SearchRepoOptions struct {
- ListOptions
+ db.ListOptions
Actor *User
Keyword string
OwnerID int64
// test search public repository on explore page
repos, count, err := SearchRepositoryByName(&SearchRepoOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 10,
},
assert.Equal(t, int64(1), count)
repos, count, err = SearchRepositoryByName(&SearchRepoOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 10,
},
// test search private repository on explore page
repos, count, err = SearchRepositoryByName(&SearchRepoOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 10,
},
assert.Equal(t, int64(1), count)
repos, count, err = SearchRepositoryByName(&SearchRepoOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 10,
},
// Test search within description
repos, count, err = SearchRepository(&SearchRepoOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 10,
},
// Test NOT search within description
repos, count, err = SearchRepository(&SearchRepoOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
Page: 1,
PageSize: 10,
},
}{
{
name: "PublicRepositoriesByName",
- opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: ListOptions{PageSize: 10}, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: db.ListOptions{PageSize: 10}, Collaborate: util.OptionalBoolFalse},
count: 7,
},
{
name: "PublicAndPrivateRepositoriesByName",
- opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: ListOptions{Page: 1, PageSize: 10}, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: db.ListOptions{Page: 1, PageSize: 10}, Private: true, Collaborate: util.OptionalBoolFalse},
count: 14,
},
{
name: "PublicAndPrivateRepositoriesByNameWithPagesizeLimitFirstPage",
- opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: ListOptions{Page: 1, PageSize: 5}, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: db.ListOptions{Page: 1, PageSize: 5}, Private: true, Collaborate: util.OptionalBoolFalse},
count: 14,
},
{
name: "PublicAndPrivateRepositoriesByNameWithPagesizeLimitSecondPage",
- opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: ListOptions{Page: 2, PageSize: 5}, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: db.ListOptions{Page: 2, PageSize: 5}, Private: true, Collaborate: util.OptionalBoolFalse},
count: 14,
},
{
name: "PublicAndPrivateRepositoriesByNameWithPagesizeLimitThirdPage",
- opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: ListOptions{Page: 3, PageSize: 5}, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: db.ListOptions{Page: 3, PageSize: 5}, Private: true, Collaborate: util.OptionalBoolFalse},
count: 14,
},
{
name: "PublicAndPrivateRepositoriesByNameWithPagesizeLimitFourthPage",
- opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: ListOptions{Page: 3, PageSize: 5}, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: db.ListOptions{Page: 3, PageSize: 5}, Private: true, Collaborate: util.OptionalBoolFalse},
count: 14,
},
{
name: "PublicRepositoriesOfUser",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Collaborate: util.OptionalBoolFalse},
count: 2,
},
{
name: "PublicRepositoriesOfUser2",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 18, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 18, Collaborate: util.OptionalBoolFalse},
count: 0,
},
{
name: "PublicRepositoriesOfUser3",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 20, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 20, Collaborate: util.OptionalBoolFalse},
count: 2,
},
{
name: "PublicAndPrivateRepositoriesOfUser",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Private: true, Collaborate: util.OptionalBoolFalse},
count: 4,
},
{
name: "PublicAndPrivateRepositoriesOfUser2",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 18, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 18, Private: true, Collaborate: util.OptionalBoolFalse},
count: 0,
},
{
name: "PublicAndPrivateRepositoriesOfUser3",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 20, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 20, Private: true, Collaborate: util.OptionalBoolFalse},
count: 4,
},
{
name: "PublicRepositoriesOfUserIncludingCollaborative",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 15},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 15},
count: 5,
},
{
name: "PublicRepositoriesOfUser2IncludingCollaborative",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 18},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 18},
count: 1,
},
{
name: "PublicRepositoriesOfUser3IncludingCollaborative",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 20},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 20},
count: 3,
},
{
name: "PublicAndPrivateRepositoriesOfUserIncludingCollaborative",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Private: true},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Private: true},
count: 9,
},
{
name: "PublicAndPrivateRepositoriesOfUser2IncludingCollaborative",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 18, Private: true},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 18, Private: true},
count: 4,
},
{
name: "PublicAndPrivateRepositoriesOfUser3IncludingCollaborative",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 20, Private: true},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 20, Private: true},
count: 7,
},
{
name: "PublicRepositoriesOfOrganization",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 17, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 17, Collaborate: util.OptionalBoolFalse},
count: 1,
},
{
name: "PublicAndPrivateRepositoriesOfOrganization",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 17, Private: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 17, Private: true, Collaborate: util.OptionalBoolFalse},
count: 2,
},
{
name: "AllPublic/PublicRepositoriesByName",
- opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: ListOptions{PageSize: 10}, AllPublic: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: db.ListOptions{PageSize: 10}, AllPublic: true, Collaborate: util.OptionalBoolFalse},
count: 7,
},
{
name: "AllPublic/PublicAndPrivateRepositoriesByName",
- opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: ListOptions{Page: 1, PageSize: 10}, Private: true, AllPublic: true, Collaborate: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{Keyword: "big_test_", ListOptions: db.ListOptions{Page: 1, PageSize: 10}, Private: true, AllPublic: true, Collaborate: util.OptionalBoolFalse},
count: 14,
},
{
name: "AllPublic/PublicRepositoriesOfUserIncludingCollaborative",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, AllPublic: true, Template: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, AllPublic: true, Template: util.OptionalBoolFalse},
count: 28,
},
{
name: "AllPublic/PublicAndPrivateRepositoriesOfUserIncludingCollaborative",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Private: true, AllPublic: true, AllLimited: true, Template: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Private: true, AllPublic: true, AllLimited: true, Template: util.OptionalBoolFalse},
count: 33,
},
{
name: "AllPublic/PublicAndPrivateRepositoriesOfUserIncludingCollaborativeByName",
- opts: &SearchRepoOptions{Keyword: "test", ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Private: true, AllPublic: true},
+ opts: &SearchRepoOptions{Keyword: "test", ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 15, Private: true, AllPublic: true},
count: 15,
},
{
name: "AllPublic/PublicAndPrivateRepositoriesOfUser2IncludingCollaborativeByName",
- opts: &SearchRepoOptions{Keyword: "test", ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 18, Private: true, AllPublic: true},
+ opts: &SearchRepoOptions{Keyword: "test", ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 18, Private: true, AllPublic: true},
count: 13,
},
{
name: "AllPublic/PublicRepositoriesOfOrganization",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, OwnerID: 17, AllPublic: true, Collaborate: util.OptionalBoolFalse, Template: util.OptionalBoolFalse},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, OwnerID: 17, AllPublic: true, Collaborate: util.OptionalBoolFalse, Template: util.OptionalBoolFalse},
count: 28,
},
{
name: "AllTemplates",
- opts: &SearchRepoOptions{ListOptions: ListOptions{Page: 1, PageSize: 10}, Template: util.OptionalBoolTrue},
+ opts: &SearchRepoOptions{ListOptions: db.ListOptions{Page: 1, PageSize: 10}, Template: util.OptionalBoolTrue},
count: 2,
},
}
import (
"strings"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/process"
case always:
break Loop
case pubkey:
- keys, err := ListGPGKeys(u.ID, ListOptions{})
+ keys, err := ListGPGKeys(u.ID, db.ListOptions{})
if err != nil {
return false, "", nil, err
}
case always:
break Loop
case pubkey:
- keys, err := ListGPGKeys(u.ID, ListOptions{})
+ keys, err := ListGPGKeys(u.ID, db.ListOptions{})
if err != nil {
return false, "", nil, err
}
case always:
break Loop
case pubkey:
- keys, err := ListGPGKeys(u.ID, ListOptions{})
+ keys, err := ListGPGKeys(u.ID, db.ListOptions{})
if err != nil {
return false, "", nil, err
}
}
// Remove redundant collaborators.
- collaborators, err := repo.getCollaborators(sess, ListOptions{})
+ collaborators, err := repo.getCollaborators(sess, db.ListOptions{})
if err != nil {
return fmt.Errorf("getCollaborators: %v", err)
}
"fmt"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/json"
"code.gitea.io/gitea/modules/timeutil"
func (r *RepoUnit) BeforeSet(colName string, val xorm.Cell) {
switch colName {
case "type":
- switch UnitType(Cell2Int64(val)) {
+ switch UnitType(login.Cell2Int64(val)) {
case UnitTypeCode, UnitTypeReleases, UnitTypeWiki, UnitTypeProjects:
r.Config = new(UnitConfig)
case UnitTypeExternalWiki:
}
// GetWatchers returns range of users watching given repository.
-func (repo *Repository) GetWatchers(opts ListOptions) ([]*User, error) {
+func (repo *Repository) GetWatchers(opts db.ListOptions) ([]*User, error) {
sess := db.GetEngine(db.DefaultContext).Where("watch.repo_id=?", repo.ID).
Join("LEFT", "watch", "`user`.id=`watch`.user_id").
And("`watch`.mode<>?", RepoWatchModeDont)
if opts.Page > 0 {
- sess = setSessionPagination(sess, &opts)
+ sess = db.SetSessionPagination(sess, &opts)
users := make([]*User, 0, opts.PageSize)
return users, sess.Find(&users)
assert.NoError(t, db.PrepareTestDatabase())
repo := db.AssertExistsAndLoadBean(t, &Repository{ID: 1}).(*Repository)
- watchers, err := repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err := repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, repo.NumWatches)
for _, watcher := range watchers {
}
repo = db.AssertExistsAndLoadBean(t, &Repository{ID: 9}).(*Repository)
- watchers, err = repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err = repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, 0)
}
assert.NoError(t, db.PrepareTestDatabase())
repo := db.AssertExistsAndLoadBean(t, &Repository{ID: 1}).(*Repository)
- watchers, err := repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err := repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, repo.NumWatches)
// Must not add watch
assert.NoError(t, WatchIfAuto(8, 1, true))
- watchers, err = repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err = repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, prevCount)
// Should not add watch
assert.NoError(t, WatchIfAuto(10, 1, true))
- watchers, err = repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err = repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, prevCount)
// Must not add watch
assert.NoError(t, WatchIfAuto(8, 1, true))
- watchers, err = repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err = repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, prevCount)
// Should not add watch
assert.NoError(t, WatchIfAuto(12, 1, false))
- watchers, err = repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err = repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, prevCount)
// Should add watch
assert.NoError(t, WatchIfAuto(12, 1, true))
- watchers, err = repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err = repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, prevCount+1)
// Should remove watch, inhibit from adding auto
assert.NoError(t, WatchRepo(12, 1, false))
- watchers, err = repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err = repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, prevCount)
// Must not add watch
assert.NoError(t, WatchIfAuto(12, 1, true))
- watchers, err = repo.GetWatchers(ListOptions{Page: 1})
+ watchers, err = repo.GetWatchers(db.ListOptions{Page: 1})
assert.NoError(t, err)
assert.Len(t, watchers, prevCount)
}
// FindReviewOptions represent possible filters to find reviews
type FindReviewOptions struct {
- ListOptions
+ db.ListOptions
Type ReviewType
IssueID int64
ReviewerID int64
reviews := make([]*Review, 0, 10)
sess := e.Where(opts.toCond())
if opts.Page > 0 {
- sess = setSessionPagination(sess, &opts)
+ sess = db.SetSessionPagination(sess, &opts)
}
return reviews, sess.
Asc("created_unix").
"time"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/util"
}
// ListPublicKeys returns a list of public keys belongs to given user.
-func ListPublicKeys(uid int64, listOptions ListOptions) ([]*PublicKey, error) {
+func ListPublicKeys(uid int64, listOptions db.ListOptions) ([]*PublicKey, error) {
sess := db.GetEngine(db.DefaultContext).Where("owner_id = ? AND type != ?", uid, KeyTypePrincipal)
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
keys := make([]*PublicKey, 0, listOptions.PageSize)
return keys, sess.Find(&keys)
// PublicKeysAreExternallyManaged returns whether the provided KeyID represents an externally managed Key
func PublicKeysAreExternallyManaged(keys []*PublicKey) ([]bool, error) {
- sources := make([]*LoginSource, 0, 5)
+ sources := make([]*login.Source, 0, 5)
externals := make([]bool, len(keys))
keyloop:
for i, key := range keys {
continue keyloop
}
- var source *LoginSource
+ var source *login.Source
sourceloop:
for _, s := range sources {
if source == nil {
var err error
- source, err = GetLoginSourceByID(key.LoginSourceID)
+ source, err = login.GetSourceByID(key.LoginSourceID)
if err != nil {
- if IsErrLoginSourceNotExist(err) {
+ if login.IsErrSourceNotExist(err) {
externals[i] = false
- sources[i] = &LoginSource{
+ sources[i] = &login.Source{
ID: key.LoginSourceID,
}
continue keyloop
}
}
- if sshKeyProvider, ok := source.Cfg.(SSHKeyProvider); ok && sshKeyProvider.ProvidesSSHKeys() {
+ if sshKeyProvider, ok := source.Cfg.(login.SSHKeyProvider); ok && sshKeyProvider.ProvidesSSHKeys() {
// Disable setting SSH keys for this user
externals[i] = true
}
if key.LoginSourceID == 0 {
return false, nil
}
- source, err := GetLoginSourceByID(key.LoginSourceID)
+ source, err := login.GetSourceByID(key.LoginSourceID)
if err != nil {
- if IsErrLoginSourceNotExist(err) {
+ if login.IsErrSourceNotExist(err) {
return false, nil
}
return false, err
}
- if sshKeyProvider, ok := source.Cfg.(SSHKeyProvider); ok && sshKeyProvider.ProvidesSSHKeys() {
+ if sshKeyProvider, ok := source.Cfg.(login.SSHKeyProvider); ok && sshKeyProvider.ProvidesSSHKeys() {
// Disable setting SSH keys for this user
return true, nil
}
}
// AddPublicKeysBySource add a users public keys. Returns true if there are changes.
-func AddPublicKeysBySource(usr *User, s *LoginSource, sshPublicKeys []string) bool {
+func AddPublicKeysBySource(usr *User, s *login.Source, sshPublicKeys []string) bool {
var sshKeysNeedUpdate bool
for _, sshKey := range sshPublicKeys {
var err error
}
// SynchronizePublicKeys updates a users public keys. Returns true if there are changes.
-func SynchronizePublicKeys(usr *User, s *LoginSource, sshPublicKeys []string) bool {
+func SynchronizePublicKeys(usr *User, s *login.Source, sshPublicKeys []string) bool {
var sshKeysNeedUpdate bool
log.Trace("synchronizePublicKeys[%s]: Handling Public SSH Key synchronization for user %s", s.Name, usr.Name)
// ListDeployKeysOptions are options for ListDeployKeys
type ListDeployKeysOptions struct {
- ListOptions
+ db.ListOptions
RepoID int64
KeyID int64
Fingerprint string
sess := e.Where(opts.toCond())
if opts.Page != 0 {
- sess = setSessionPagination(sess, opts)
+ sess = db.SetSessionPagination(sess, opts)
keys := make([]*DeployKey, 0, opts.PageSize)
return keys, sess.Find(&keys)
}
// ListPrincipalKeys returns a list of principals belongs to given user.
-func ListPrincipalKeys(uid int64, listOptions ListOptions) ([]*PublicKey, error) {
+func ListPrincipalKeys(uid int64, listOptions db.ListOptions) ([]*PublicKey, error) {
sess := db.GetEngine(db.DefaultContext).Where("owner_id = ? AND type = ?", uid, KeyTypePrincipal)
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
keys := make([]*PublicKey, 0, listOptions.PageSize)
return keys, sess.Find(&keys)
}
// GetStargazers returns the users that starred the repo.
-func (repo *Repository) GetStargazers(opts ListOptions) ([]*User, error) {
+func (repo *Repository) GetStargazers(opts db.ListOptions) ([]*User, error) {
sess := db.GetEngine(db.DefaultContext).Where("star.repo_id = ?", repo.ID).
Join("LEFT", "star", "`user`.id = star.uid")
if opts.Page > 0 {
- sess = setSessionPagination(sess, &opts)
+ sess = db.SetSessionPagination(sess, &opts)
users := make([]*User, 0, opts.PageSize)
return users, sess.Find(&users)
// repo with stargazers
assert.NoError(t, db.PrepareTestDatabase())
repo := db.AssertExistsAndLoadBean(t, &Repository{ID: 4}).(*Repository)
- gazers, err := repo.GetStargazers(ListOptions{Page: 0})
+ gazers, err := repo.GetStargazers(db.ListOptions{Page: 0})
assert.NoError(t, err)
if assert.Len(t, gazers, 1) {
assert.Equal(t, int64(2), gazers[0].ID)
// repo with stargazers
assert.NoError(t, db.PrepareTestDatabase())
repo := db.AssertExistsAndLoadBean(t, &Repository{ID: 3}).(*Repository)
- gazers, err := repo.GetStargazers(ListOptions{Page: 0})
+ gazers, err := repo.GetStargazers(db.ListOptions{Page: 0})
assert.NoError(t, err)
assert.Len(t, gazers, 0)
}
package models
-import "code.gitea.io/gitea/models/db"
+import (
+ "code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
+)
// Statistic contains the database statistics
type Statistic struct {
stats.Counter.Follow, _ = db.GetEngine(db.DefaultContext).Count(new(Follow))
stats.Counter.Mirror, _ = db.GetEngine(db.DefaultContext).Count(new(Mirror))
stats.Counter.Release, _ = db.GetEngine(db.DefaultContext).Count(new(Release))
- stats.Counter.LoginSource = CountLoginSources()
+ stats.Counter.LoginSource = login.CountSources()
stats.Counter.Webhook, _ = db.GetEngine(db.DefaultContext).Count(new(Webhook))
stats.Counter.Milestone, _ = db.GetEngine(db.DefaultContext).Count(new(Milestone))
stats.Counter.Label, _ = db.GetEngine(db.DefaultContext).Count(new(Label))
// ListAccessTokensOptions contain filter options
type ListAccessTokensOptions struct {
- ListOptions
+ db.ListOptions
Name string
UserID int64
}
sess = sess.Desc("id")
if opts.Page != 0 {
- sess = setSessionPagination(sess, &opts)
+ sess = db.SetSessionPagination(sess, &opts)
tokens := make([]*AccessToken, 0, opts.PageSize)
return tokens, sess.Find(&tokens)
// FindTopicOptions represents the options when fdin topics
type FindTopicOptions struct {
- ListOptions
+ db.ListOptions
RepoID int64
Keyword string
}
sess.Join("INNER", "repo_topic", "repo_topic.topic_id = topic.id")
}
if opts.PageSize != 0 && opts.Page != 0 {
- sess = setSessionPagination(sess, opts)
+ sess = db.SetSessionPagination(sess, opts)
}
topics := make([]*Topic, 0, 10)
total, err := sess.Desc("topic.repo_count").FindAndCount(&topics)
assert.Len(t, topics, totalNrOfTopics)
topics, total, err := FindTopics(&FindTopicOptions{
- ListOptions: ListOptions{Page: 1, PageSize: 2},
+ ListOptions: db.ListOptions{Page: 1, PageSize: 2},
})
assert.NoError(t, err)
assert.Len(t, topics, 2)
"unicode/utf8"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/log"
// is to change his/her password after registration.
MustChangePassword bool `xorm:"NOT NULL DEFAULT false"`
- LoginType LoginType
+ LoginType login.Type
LoginSource int64 `xorm:"NOT NULL DEFAULT 0"`
LoginName string
Type UserType
// SearchOrganizationsOptions options to filter organizations
type SearchOrganizationsOptions struct {
- ListOptions
+ db.ListOptions
All bool
}
// IsLocal returns true if user login type is LoginPlain.
func (u *User) IsLocal() bool {
- return u.LoginType <= LoginPlain
+ return u.LoginType <= login.Plain
}
// IsOAuth2 returns true if user login type is LoginOAuth2.
func (u *User) IsOAuth2() bool {
- return u.LoginType == LoginOAuth2
+ return u.LoginType == login.OAuth2
}
// HasForkedRepo checks if user has already forked a repository with given ID.
}
// GetFollowers returns range of user's followers.
-func (u *User) GetFollowers(listOptions ListOptions) ([]*User, error) {
+func (u *User) GetFollowers(listOptions db.ListOptions) ([]*User, error) {
sess := db.GetEngine(db.DefaultContext).
Where("follow.follow_id=?", u.ID).
Join("LEFT", "follow", "`user`.id=follow.user_id")
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
users := make([]*User, 0, listOptions.PageSize)
return users, sess.Find(&users)
}
// GetFollowing returns range of user's following.
-func (u *User) GetFollowing(listOptions ListOptions) ([]*User, error) {
+func (u *User) GetFollowing(listOptions db.ListOptions) ([]*User, error) {
sess := db.GetEngine(db.DefaultContext).
Where("follow.user_id=?", u.ID).
Join("LEFT", "follow", "`user`.id=follow.follow_id")
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
users := make([]*User, 0, listOptions.PageSize)
return users, sess.Find(&users)
}
// GetRepositories returns repositories that user owns, including private repositories.
-func (u *User) GetRepositories(listOpts ListOptions, names ...string) (err error) {
+func (u *User) GetRepositories(listOpts db.ListOptions, names ...string) (err error) {
u.Repos, _, err = GetUserRepositories(&SearchRepoOptions{Actor: u, Private: true, ListOptions: listOpts, LowerNames: names})
return err
}
// ***** END: PublicKey *****
// ***** START: GPGPublicKey *****
- keys, err := listGPGKeys(e, u.ID, ListOptions{})
+ keys, err := listGPGKeys(e, u.ID, db.ListOptions{})
if err != nil {
return fmt.Errorf("ListGPGKeys: %v", err)
}
}
// GetUsersBySource returns a list of Users for a login source
-func GetUsersBySource(s *LoginSource) ([]*User, error) {
+func GetUsersBySource(s *login.Source) ([]*User, error) {
var users []*User
err := db.GetEngine(db.DefaultContext).Where("login_type = ? AND login_source = ?", s.Type, s.ID).Find(&users)
return users, err
// SearchUserOptions contains the options for searching
type SearchUserOptions struct {
- ListOptions
+ db.ListOptions
Keyword string
Type UserType
UID int64
sess := db.GetEngine(db.DefaultContext).Where(cond).OrderBy(opts.OrderBy.String())
if opts.Page != 0 {
- sess = setSessionPagination(sess, opts)
+ sess = db.SetSessionPagination(sess, opts)
}
users = make([]*User, 0, opts.PageSize)
}
// GetStarredRepos returns the repos starred by a particular user
-func GetStarredRepos(userID int64, private bool, listOptions ListOptions) ([]*Repository, error) {
+func GetStarredRepos(userID int64, private bool, listOptions db.ListOptions) ([]*Repository, error) {
sess := db.GetEngine(db.DefaultContext).Where("star.uid=?", userID).
Join("LEFT", "star", "`repository`.id=`star`.repo_id")
if !private {
}
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
repos := make([]*Repository, 0, listOptions.PageSize)
return repos, sess.Find(&repos)
}
// GetWatchedRepos returns the repos watched by a particular user
-func GetWatchedRepos(userID int64, private bool, listOptions ListOptions) ([]*Repository, int64, error) {
+func GetWatchedRepos(userID int64, private bool, listOptions db.ListOptions) ([]*Repository, int64, error) {
sess := db.GetEngine(db.DefaultContext).Where("watch.user_id=?", userID).
And("`watch`.mode<>?", RepoWatchModeDont).
Join("LEFT", "watch", "`repository`.id=`watch`.repo_id")
}
if listOptions.Page != 0 {
- sess = setSessionPagination(sess, &listOptions)
+ sess = db.SetSessionPagination(sess, &listOptions)
repos := make([]*Repository, 0, listOptions.PageSize)
total, err := sess.FindAndCount(&repos)
// SearchEmailOptions are options to search e-mail addresses for the admin panel
type SearchEmailOptions struct {
- ListOptions
+ db.ListOptions
Keyword string
SortType SearchEmailOrderBy
IsPrimary util.OptionalBool
orderby = SearchEmailOrderByEmail.String()
}
- opts.setDefaultValues()
+ opts.SetDefaultValues()
emails := make([]*SearchEmailResult, 0, opts.PageSize)
err = db.GetEngine(db.DefaultContext).Table("email_address").
// Must find all users and their emails
opts := &SearchEmailOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
PageSize: 10000,
},
}
// Must find more than one page, but retrieve only one
opts = &SearchEmailOptions{
- ListOptions: ListOptions{
+ ListOptions: db.ListOptions{
PageSize: 5,
Page: 1,
},
"testing"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/modules/util"
"github.com/stretchr/testify/assert"
)
+func TestOAuth2Application_LoadUser(t *testing.T) {
+ assert.NoError(t, db.PrepareTestDatabase())
+ app := db.AssertExistsAndLoadBean(t, &login.OAuth2Application{ID: 1}).(*login.OAuth2Application)
+ user, err := GetUserByID(app.UID)
+ assert.NoError(t, err)
+ assert.NotNil(t, user)
+}
+
func TestUserIsPublicMember(t *testing.T) {
assert.NoError(t, db.PrepareTestDatabase())
testSuccess(opts, expectedOrgIDs)
}
- testOrgSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: ListOptions{Page: 1, PageSize: 2}},
+ testOrgSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: db.ListOptions{Page: 1, PageSize: 2}},
[]int64{3, 6})
- testOrgSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: ListOptions{Page: 2, PageSize: 2}},
+ testOrgSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: db.ListOptions{Page: 2, PageSize: 2}},
[]int64{7, 17})
- testOrgSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: ListOptions{Page: 3, PageSize: 2}},
+ testOrgSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: db.ListOptions{Page: 3, PageSize: 2}},
[]int64{19, 25})
- testOrgSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: ListOptions{Page: 4, PageSize: 2}},
+ testOrgSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: db.ListOptions{Page: 4, PageSize: 2}},
[]int64{26})
- testOrgSuccess(&SearchUserOptions{ListOptions: ListOptions{Page: 5, PageSize: 2}},
+ testOrgSuccess(&SearchUserOptions{ListOptions: db.ListOptions{Page: 5, PageSize: 2}},
[]int64{})
// test users
testSuccess(opts, expectedUserIDs)
}
- testUserSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: ListOptions{Page: 1}},
+ testUserSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: db.ListOptions{Page: 1}},
[]int64{1, 2, 4, 5, 8, 9, 10, 11, 12, 13, 14, 15, 16, 18, 20, 21, 24, 27, 28, 29, 30})
- testUserSuccess(&SearchUserOptions{ListOptions: ListOptions{Page: 1}, IsActive: util.OptionalBoolFalse},
+ testUserSuccess(&SearchUserOptions{ListOptions: db.ListOptions{Page: 1}, IsActive: util.OptionalBoolFalse},
[]int64{9})
- testUserSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: ListOptions{Page: 1}, IsActive: util.OptionalBoolTrue},
+ testUserSuccess(&SearchUserOptions{OrderBy: "id ASC", ListOptions: db.ListOptions{Page: 1}, IsActive: util.OptionalBoolTrue},
[]int64{1, 2, 4, 5, 8, 10, 11, 12, 13, 14, 15, 16, 18, 20, 21, 24, 28, 29, 30})
- testUserSuccess(&SearchUserOptions{Keyword: "user1", OrderBy: "id ASC", ListOptions: ListOptions{Page: 1}, IsActive: util.OptionalBoolTrue},
+ testUserSuccess(&SearchUserOptions{Keyword: "user1", OrderBy: "id ASC", ListOptions: db.ListOptions{Page: 1}, IsActive: util.OptionalBoolTrue},
[]int64{1, 10, 11, 12, 13, 14, 15, 16, 18})
// order by name asc default
- testUserSuccess(&SearchUserOptions{Keyword: "user1", ListOptions: ListOptions{Page: 1}, IsActive: util.OptionalBoolTrue},
+ testUserSuccess(&SearchUserOptions{Keyword: "user1", ListOptions: db.ListOptions{Page: 1}, IsActive: util.OptionalBoolTrue},
[]int64{1, 10, 11, 12, 13, 14, 15, 16, 18})
}
assert.NoError(t, db.PrepareTestDatabase())
user := db.AssertExistsAndLoadBean(t, &User{ID: 2}).(*User)
- s := &LoginSource{ID: 1}
+ s := &login.Source{ID: 1}
testCases := []struct {
keyString string
// ListWebhookOptions are options to filter webhooks on ListWebhooksByOpts
type ListWebhookOptions struct {
- ListOptions
+ db.ListOptions
RepoID int64
OrgID int64
IsActive util.OptionalBool
sess := e.Where(opts.toCond())
if opts.Page != 0 {
- sess = setSessionPagination(sess, opts)
+ sess = db.SetSessionPagination(sess, opts)
webhooks := make([]*Webhook, 0, opts.PageSize)
err := sess.Find(&webhooks)
return webhooks, err
"time"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/structs"
}
}
-// ToOAuth2Application convert from models.OAuth2Application to api.OAuth2Application
-func ToOAuth2Application(app *models.OAuth2Application) *api.OAuth2Application {
+// ToOAuth2Application convert from login.OAuth2Application to api.OAuth2Application
+func ToOAuth2Application(app *login.OAuth2Application) *api.OAuth2Application {
return &api.OAuth2Application{
ID: app.ID,
Name: app.Name,
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/log"
)
_ = models.CalculateTrustStatus(c.Verification, repository, &keyMap)
- statuses, err := models.GetLatestCommitStatus(repository.ID, c.Commit.ID.String(), models.ListOptions{})
+ statuses, err := models.GetLatestCommitStatus(repository.ID, c.Commit.ID.String(), db.ListOptions{})
if err != nil {
log.Error("GetLatestCommitStatus: %v", err)
} else {
"time"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/graceful"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/queue"
default:
}
repos, _, err := models.SearchRepositoryByName(&models.SearchRepoOptions{
- ListOptions: models.ListOptions{Page: page, PageSize: models.RepositoryListDefaultPageSize},
+ ListOptions: db.ListOptions{Page: page, PageSize: models.RepositoryListDefaultPageSize},
OrderBy: models.SearchOrderByID,
Private: true,
Collaborate: util.OptionalBoolFalse,
assert.NoError(t, err)
assert.Empty(t, milestones)
- labels, err := models.GetLabelsByRepoID(repo.ID, "", models.ListOptions{})
+ labels, err := models.GetLabelsByRepoID(repo.ID, "", db.ListOptions{})
assert.NoError(t, err)
assert.Len(t, labels, 12)
releases, err := models.GetReleasesByRepoID(repo.ID, models.FindReleasesOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: 10,
Page: 0,
},
assert.Len(t, releases, 8)
releases, err = models.GetReleasesByRepoID(repo.ID, models.FindReleasesOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: 10,
Page: 0,
},
}
// ListUnadoptedRepositories lists all the unadopted repositories that match the provided query
-func ListUnadoptedRepositories(query string, opts *models.ListOptions) ([]string, int, error) {
+func ListUnadoptedRepositories(query string, opts *db.ListOptions) ([]string, int, error) {
globUser, _ := glob.Compile("*")
globRepo, _ := glob.Compile("*")
// Clean up old repoNamesToCheck
if len(repoNamesToCheck) > 0 {
- repos, _, err := models.GetUserRepositories(&models.SearchRepoOptions{Actor: ctxUser, Private: true, ListOptions: models.ListOptions{
- Page: 1,
- PageSize: opts.PageSize,
- }, LowerNames: repoNamesToCheck})
+ repos, _, err := models.GetUserRepositories(&models.SearchRepoOptions{
+ Actor: ctxUser,
+ Private: true,
+ ListOptions: db.ListOptions{
+ Page: 1,
+ PageSize: opts.PageSize,
+ }, LowerNames: repoNamesToCheck})
if err != nil {
return err
}
if count < end {
repoNamesToCheck = append(repoNamesToCheck, name)
if len(repoNamesToCheck) >= opts.PageSize {
- repos, _, err := models.GetUserRepositories(&models.SearchRepoOptions{Actor: ctxUser, Private: true, ListOptions: models.ListOptions{
- Page: 1,
- PageSize: opts.PageSize,
- }, LowerNames: repoNamesToCheck})
+ repos, _, err := models.GetUserRepositories(&models.SearchRepoOptions{
+ Actor: ctxUser,
+ Private: true,
+ ListOptions: db.ListOptions{
+ Page: 1,
+ PageSize: opts.PageSize,
+ }, LowerNames: repoNamesToCheck})
if err != nil {
return err
}
}
if len(repoNamesToCheck) > 0 {
- repos, _, err := models.GetUserRepositories(&models.SearchRepoOptions{Actor: ctxUser, Private: true, ListOptions: models.ListOptions{
- Page: 1,
- PageSize: opts.PageSize,
- }, LowerNames: repoNamesToCheck})
+ repos, _, err := models.GetUserRepositories(&models.SearchRepoOptions{
+ Actor: ctxUser,
+ Private: true,
+ ListOptions: db.ListOptions{
+ Page: 1,
+ PageSize: opts.PageSize,
+ }, LowerNames: repoNamesToCheck})
if err != nil {
return nil, 0, err
}
// SyncReleasesWithTags synchronizes release table with repository tags
func SyncReleasesWithTags(repo *models.Repository, gitRepo *git.Repository) error {
existingRelTags := make(map[string]struct{})
- opts := models.FindReleasesOptions{IncludeDrafts: true, IncludeTags: true, ListOptions: models.ListOptions{PageSize: 50}}
+ opts := models.FindReleasesOptions{
+ IncludeDrafts: true,
+ IncludeTags: true,
+ ListOptions: db.ListOptions{PageSize: 50},
+ }
for page := 1; ; page++ {
opts.Page = page
rels, err := models.GetReleasesByRepoID(repo.ID, opts)
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
"code.gitea.io/gitea/modules/log"
return
}
- source, err := models.GetLoginSourceByID(sourceID)
+ source, err := login.GetSourceByID(sourceID)
if err != nil {
- if models.IsErrLoginSourceNotExist(err) {
+ if login.IsErrSourceNotExist(err) {
ctx.Error(http.StatusUnprocessableEntity, "", err)
} else {
- ctx.Error(http.StatusInternalServerError, "GetLoginSourceByID", err)
+ ctx.Error(http.StatusInternalServerError, "login.GetSourceByID", err)
}
return
}
Passwd: form.Password,
MustChangePassword: true,
IsActive: true,
- LoginType: models.LoginPlain,
+ LoginType: login.Plain,
}
if form.MustChangePassword != nil {
u.MustChangePassword = *form.MustChangePassword
"time"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
issue_indexer "code.gitea.io/gitea/modules/indexer/issues"
// This would otherwise return all issues if no issues were found by the search.
if len(keyword) == 0 || len(issueIDs) > 0 || len(includedLabelNames) > 0 || len(includedMilestones) > 0 {
issuesOpt := &models.IssuesOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
Page: ctx.FormInt("page"),
PageSize: limit,
},
return
}
- issuesOpt.ListOptions = models.ListOptions{
+ issuesOpt.ListOptions = db.ListOptions{
Page: -1,
}
if filteredCount, err = models.CountIssues(issuesOpt); err != nil {
return
}
- issuesOpt.ListOptions = models.ListOptions{
+ issuesOpt.ListOptions = db.ListOptions{
Page: -1,
}
if filteredCount, err = models.CountIssues(issuesOpt); err != nil {
"strconv"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
api "code.gitea.io/gitea/modules/structs"
data := web.GetForm(ctx).(*api.CreateOAuth2ApplicationOptions)
- app, err := models.CreateOAuth2Application(models.CreateOAuth2ApplicationOptions{
+ app, err := login.CreateOAuth2Application(login.CreateOAuth2ApplicationOptions{
Name: data.Name,
UserID: ctx.User.ID,
RedirectURIs: data.RedirectURIs,
// "200":
// "$ref": "#/responses/OAuth2ApplicationList"
- apps, total, err := models.ListOAuth2Applications(ctx.User.ID, utils.GetListOptions(ctx))
+ apps, total, err := login.ListOAuth2Applications(ctx.User.ID, utils.GetListOptions(ctx))
if err != nil {
ctx.Error(http.StatusInternalServerError, "ListOAuth2Applications", err)
return
// "404":
// "$ref": "#/responses/notFound"
appID := ctx.ParamsInt64(":id")
- if err := models.DeleteOAuth2Application(appID, ctx.User.ID); err != nil {
- if models.IsErrOAuthApplicationNotFound(err) {
+ if err := login.DeleteOAuth2Application(appID, ctx.User.ID); err != nil {
+ if login.IsErrOAuthApplicationNotFound(err) {
ctx.NotFound()
} else {
ctx.Error(http.StatusInternalServerError, "DeleteOauth2ApplicationByID", err)
// "404":
// "$ref": "#/responses/notFound"
appID := ctx.ParamsInt64(":id")
- app, err := models.GetOAuth2ApplicationByID(appID)
+ app, err := login.GetOAuth2ApplicationByID(appID)
if err != nil {
- if models.IsErrOauthClientIDInvalid(err) || models.IsErrOAuthApplicationNotFound(err) {
+ if login.IsErrOauthClientIDInvalid(err) || login.IsErrOAuthApplicationNotFound(err) {
ctx.NotFound()
} else {
ctx.Error(http.StatusInternalServerError, "GetOauth2ApplicationByID", err)
data := web.GetForm(ctx).(*api.CreateOAuth2ApplicationOptions)
- app, err := models.UpdateOAuth2Application(models.UpdateOAuth2ApplicationOptions{
+ app, err := login.UpdateOAuth2Application(login.UpdateOAuth2ApplicationOptions{
Name: data.Name,
UserID: ctx.User.ID,
ID: appID,
RedirectURIs: data.RedirectURIs,
})
if err != nil {
- if models.IsErrOauthClientIDInvalid(err) || models.IsErrOAuthApplicationNotFound(err) {
+ if login.IsErrOauthClientIDInvalid(err) || login.IsErrOAuthApplicationNotFound(err) {
ctx.NotFound()
} else {
ctx.Error(http.StatusInternalServerError, "UpdateOauth2ApplicationByID", err)
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
api "code.gitea.io/gitea/modules/structs"
"code.gitea.io/gitea/routers/api/v1/utils"
)
-func listGPGKeys(ctx *context.APIContext, uid int64, listOptions models.ListOptions) {
+func listGPGKeys(ctx *context.APIContext, uid int64, listOptions db.ListOptions) {
keys, err := models.ListGPGKeys(uid, listOptions)
if err != nil {
ctx.Error(http.StatusInternalServerError, "ListGPGKeys", err)
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
api "code.gitea.io/gitea/modules/structs"
// getStarredRepos returns the repos that the user with the specified userID has
// starred
-func getStarredRepos(user *models.User, private bool, listOptions models.ListOptions) ([]*api.Repository, error) {
+func getStarredRepos(user *models.User, private bool, listOptions db.ListOptions) ([]*api.Repository, error) {
starredRepos, err := models.GetStarredRepos(user.ID, private, listOptions)
if err != nil {
return nil, err
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
api "code.gitea.io/gitea/modules/structs"
)
// getWatchedRepos returns the repos that the user with the specified userID is watching
-func getWatchedRepos(user *models.User, private bool, listOptions models.ListOptions) ([]*api.Repository, int64, error) {
+func getWatchedRepos(user *models.User, private bool, listOptions db.ListOptions) ([]*api.Repository, int64, error) {
watchedRepos, total, err := models.GetWatchedRepos(user.ID, private, listOptions)
if err != nil {
return nil, 0, err
"strings"
"time"
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
)
}
// GetListOptions returns list options using the page and limit parameters
-func GetListOptions(ctx *context.APIContext) models.ListOptions {
- return models.ListOptions{
+func GetListOptions(ctx *context.APIContext) db.ListOptions {
+ return db.ListOptions{
Page: ctx.FormInt("page"),
PageSize: convert.ToCorrectPageSize(ctx.FormInt("limit")),
}
"regexp"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/auth/pam"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/modules/util"
"code.gitea.io/gitea/modules/web"
+ auth_service "code.gitea.io/gitea/services/auth"
"code.gitea.io/gitea/services/auth/source/ldap"
"code.gitea.io/gitea/services/auth/source/oauth2"
pamService "code.gitea.io/gitea/services/auth/source/pam"
ctx.Data["PageIsAdminAuthentications"] = true
var err error
- ctx.Data["Sources"], err = models.LoginSources()
+ ctx.Data["Sources"], err = login.Sources()
if err != nil {
- ctx.ServerError("LoginSources", err)
+ ctx.ServerError("login.Sources", err)
return
}
- ctx.Data["Total"] = models.CountLoginSources()
+ ctx.Data["Total"] = login.CountSources()
ctx.HTML(http.StatusOK, tplAuths)
}
var (
authSources = func() []dropdownItem {
items := []dropdownItem{
- {models.LoginNames[models.LoginLDAP], models.LoginLDAP},
- {models.LoginNames[models.LoginDLDAP], models.LoginDLDAP},
- {models.LoginNames[models.LoginSMTP], models.LoginSMTP},
- {models.LoginNames[models.LoginOAuth2], models.LoginOAuth2},
- {models.LoginNames[models.LoginSSPI], models.LoginSSPI},
+ {login.LDAP.String(), login.LDAP},
+ {login.DLDAP.String(), login.DLDAP},
+ {login.SMTP.String(), login.SMTP},
+ {login.OAuth2.String(), login.OAuth2},
+ {login.SSPI.String(), login.SSPI},
}
if pam.Supported {
- items = append(items, dropdownItem{models.LoginNames[models.LoginPAM], models.LoginPAM})
+ items = append(items, dropdownItem{login.Names[login.PAM], login.PAM})
}
return items
}()
ctx.Data["PageIsAdmin"] = true
ctx.Data["PageIsAdminAuthentications"] = true
- ctx.Data["type"] = models.LoginLDAP
- ctx.Data["CurrentTypeName"] = models.LoginNames[models.LoginLDAP]
+ ctx.Data["type"] = login.LDAP
+ ctx.Data["CurrentTypeName"] = login.Names[login.LDAP]
ctx.Data["CurrentSecurityProtocol"] = ldap.SecurityProtocolNames[ldap.SecurityProtocolUnencrypted]
ctx.Data["smtp_auth"] = "PLAIN"
ctx.Data["is_active"] = true
ctx.Data["PageIsAdmin"] = true
ctx.Data["PageIsAdminAuthentications"] = true
- ctx.Data["CurrentTypeName"] = models.LoginNames[models.LoginType(form.Type)]
+ ctx.Data["CurrentTypeName"] = login.Type(form.Type).String()
ctx.Data["CurrentSecurityProtocol"] = ldap.SecurityProtocolNames[ldap.SecurityProtocol(form.SecurityProtocol)]
ctx.Data["AuthSources"] = authSources
ctx.Data["SecurityProtocols"] = securityProtocols
hasTLS := false
var config convert.Conversion
- switch models.LoginType(form.Type) {
- case models.LoginLDAP, models.LoginDLDAP:
+ switch login.Type(form.Type) {
+ case login.LDAP, login.DLDAP:
config = parseLDAPConfig(form)
hasTLS = ldap.SecurityProtocol(form.SecurityProtocol) > ldap.SecurityProtocolUnencrypted
- case models.LoginSMTP:
+ case login.SMTP:
config = parseSMTPConfig(form)
hasTLS = true
- case models.LoginPAM:
+ case login.PAM:
config = &pamService.Source{
ServiceName: form.PAMServiceName,
EmailDomain: form.PAMEmailDomain,
}
- case models.LoginOAuth2:
+ case login.OAuth2:
config = parseOAuth2Config(form)
- case models.LoginSSPI:
+ case login.SSPI:
var err error
config, err = parseSSPIConfig(ctx, form)
if err != nil {
ctx.RenderWithErr(err.Error(), tplAuthNew, form)
return
}
- existing, err := models.LoginSourcesByType(models.LoginSSPI)
+ existing, err := login.SourcesByType(login.SSPI)
if err != nil || len(existing) > 0 {
ctx.Data["Err_Type"] = true
ctx.RenderWithErr(ctx.Tr("admin.auths.login_source_of_type_exist"), tplAuthNew, form)
return
}
- if err := models.CreateLoginSource(&models.LoginSource{
- Type: models.LoginType(form.Type),
+ if err := login.CreateSource(&login.Source{
+ Type: login.Type(form.Type),
Name: form.Name,
IsActive: form.IsActive,
IsSyncEnabled: form.IsSyncEnabled,
Cfg: config,
}); err != nil {
- if models.IsErrLoginSourceAlreadyExist(err) {
+ if login.IsErrSourceAlreadyExist(err) {
ctx.Data["Err_Name"] = true
- ctx.RenderWithErr(ctx.Tr("admin.auths.login_source_exist", err.(models.ErrLoginSourceAlreadyExist).Name), tplAuthNew, form)
+ ctx.RenderWithErr(ctx.Tr("admin.auths.login_source_exist", err.(login.ErrSourceAlreadyExist).Name), tplAuthNew, form)
} else {
- ctx.ServerError("CreateSource", err)
+ ctx.ServerError("login.CreateSource", err)
}
return
}
oauth2providers := oauth2.GetOAuth2Providers()
ctx.Data["OAuth2Providers"] = oauth2providers
- source, err := models.GetLoginSourceByID(ctx.ParamsInt64(":authid"))
+ source, err := login.GetSourceByID(ctx.ParamsInt64(":authid"))
if err != nil {
- ctx.ServerError("GetLoginSourceByID", err)
+ ctx.ServerError("login.GetSourceByID", err)
return
}
ctx.Data["Source"] = source
oauth2providers := oauth2.GetOAuth2Providers()
ctx.Data["OAuth2Providers"] = oauth2providers
- source, err := models.GetLoginSourceByID(ctx.ParamsInt64(":authid"))
+ source, err := login.GetSourceByID(ctx.ParamsInt64(":authid"))
if err != nil {
- ctx.ServerError("GetLoginSourceByID", err)
+ ctx.ServerError("login.GetSourceByID", err)
return
}
ctx.Data["Source"] = source
}
var config convert.Conversion
- switch models.LoginType(form.Type) {
- case models.LoginLDAP, models.LoginDLDAP:
+ switch login.Type(form.Type) {
+ case login.LDAP, login.DLDAP:
config = parseLDAPConfig(form)
- case models.LoginSMTP:
+ case login.SMTP:
config = parseSMTPConfig(form)
- case models.LoginPAM:
+ case login.PAM:
config = &pamService.Source{
ServiceName: form.PAMServiceName,
EmailDomain: form.PAMEmailDomain,
}
- case models.LoginOAuth2:
+ case login.OAuth2:
config = parseOAuth2Config(form)
- case models.LoginSSPI:
+ case login.SSPI:
config, err = parseSSPIConfig(ctx, form)
if err != nil {
ctx.RenderWithErr(err.Error(), tplAuthEdit, form)
source.IsActive = form.IsActive
source.IsSyncEnabled = form.IsSyncEnabled
source.Cfg = config
- if err := models.UpdateSource(source); err != nil {
+ if err := login.UpdateSource(source); err != nil {
if models.IsErrOpenIDConnectInitialize(err) {
ctx.Flash.Error(err.Error(), true)
ctx.HTML(http.StatusOK, tplAuthEdit)
// DeleteAuthSource response for deleting an auth source
func DeleteAuthSource(ctx *context.Context) {
- source, err := models.GetLoginSourceByID(ctx.ParamsInt64(":authid"))
+ source, err := login.GetSourceByID(ctx.ParamsInt64(":authid"))
if err != nil {
- ctx.ServerError("GetLoginSourceByID", err)
+ ctx.ServerError("login.GetSourceByID", err)
return
}
- if err = models.DeleteSource(source); err != nil {
- if models.IsErrLoginSourceInUse(err) {
+ if err = auth_service.DeleteLoginSource(source); err != nil {
+ if login.IsErrSourceInUse(err) {
ctx.Flash.Error(ctx.Tr("admin.auths.still_in_used"))
} else {
- ctx.Flash.Error(fmt.Sprintf("DeleteSource: %v", err))
+ ctx.Flash.Error(fmt.Sprintf("DeleteLoginSource: %v", err))
}
ctx.JSON(http.StatusOK, map[string]interface{}{
"redirect": setting.AppSubURL + "/admin/auths/" + ctx.Params(":authid"),
"net/url"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
ctx.Data["PageIsAdminEmails"] = true
opts := &models.SearchEmailOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: setting.UI.Admin.UserPagingNum,
Page: ctx.FormInt("page"),
},
import (
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
explore.RenderUserSearch(ctx, &models.SearchUserOptions{
Actor: ctx.User,
Type: models.UserTypeOrganization,
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: setting.UI.Admin.OrgPagingNum,
},
Visible: []structs.VisibleType{structs.VisibleTypePublic, structs.VisibleTypeLimited, structs.VisibleTypePrivate},
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
ctx.Data["PageIsAdmin"] = true
ctx.Data["PageIsAdminRepositories"] = true
- opts := models.ListOptions{
+ opts := db.ListOptions{
PageSize: setting.UI.Admin.UserPagingNum,
Page: ctx.FormInt("page"),
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
explore.RenderUserSearch(ctx, &models.SearchUserOptions{
Actor: ctx.User,
Type: models.UserTypeIndividual,
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: setting.UI.Admin.UserPagingNum,
},
SearchByEmail: true,
ctx.Data["login_type"] = "0-0"
- sources, err := models.LoginSources()
+ sources, err := login.Sources()
if err != nil {
- ctx.ServerError("LoginSources", err)
+ ctx.ServerError("login.Sources", err)
return
}
ctx.Data["Sources"] = sources
ctx.Data["PageIsAdminUsers"] = true
ctx.Data["DefaultUserVisibilityMode"] = setting.Service.DefaultUserVisibilityMode
- sources, err := models.LoginSources()
+ sources, err := login.Sources()
if err != nil {
- ctx.ServerError("LoginSources", err)
+ ctx.ServerError("login.Sources", err)
return
}
ctx.Data["Sources"] = sources
Email: form.Email,
Passwd: form.Password,
IsActive: true,
- LoginType: models.LoginPlain,
+ LoginType: login.Plain,
}
if len(form.LoginType) > 0 {
fields := strings.Split(form.LoginType, "-")
if len(fields) == 2 {
lType, _ := strconv.ParseInt(fields[0], 10, 0)
- u.LoginType = models.LoginType(lType)
+ u.LoginType = login.Type(lType)
u.LoginSource, _ = strconv.ParseInt(fields[1], 10, 64)
u.LoginName = form.LoginName
}
}
- if u.LoginType == models.LoginNoType || u.LoginType == models.LoginPlain {
+ if u.LoginType == login.NoType || u.LoginType == login.Plain {
if len(form.Password) < setting.MinPasswordLength {
ctx.Data["Err_Password"] = true
ctx.RenderWithErr(ctx.Tr("auth.password_too_short", setting.MinPasswordLength), tplUserNew, &form)
ctx.Data["User"] = u
if u.LoginSource > 0 {
- ctx.Data["LoginSource"], err = models.GetLoginSourceByID(u.LoginSource)
+ ctx.Data["LoginSource"], err = login.GetSourceByID(u.LoginSource)
if err != nil {
- ctx.ServerError("GetLoginSourceByID", err)
+ ctx.ServerError("login.GetSourceByID", err)
return nil
}
} else {
- ctx.Data["LoginSource"] = &models.LoginSource{}
+ ctx.Data["LoginSource"] = &login.Source{}
}
- sources, err := models.LoginSources()
+ sources, err := login.Sources()
if err != nil {
- ctx.ServerError("LoginSources", err)
+ ctx.ServerError("login.Sources", err)
return nil
}
ctx.Data["Sources"] = sources
if u.LoginSource != loginSource {
u.LoginSource = loginSource
- u.LoginType = models.LoginType(loginType)
+ u.LoginType = login.Type(loginType)
}
}
"time"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
"code.gitea.io/gitea/modules/eventsource"
go unregister()
break loop
case <-stopwatchTimer.C:
- sws, err := models.GetUserStopwatches(ctx.User.ID, models.ListOptions{})
+ sws, err := models.GetUserStopwatches(ctx.User.ID, db.ListOptions{})
if err != nil {
log.Error("Unable to GetUserStopwatches: %v", err)
continue
import (
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
RenderUserSearch(ctx, &models.SearchUserOptions{
Actor: ctx.User,
Type: models.UserTypeOrganization,
- ListOptions: models.ListOptions{PageSize: setting.UI.ExplorePagingNum},
+ ListOptions: db.ListOptions{PageSize: setting.UI.ExplorePagingNum},
Visible: visibleTypes,
}, tplExploreOrganizations)
}
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
ctx.Data["TopicOnly"] = topicOnly
repos, count, err = models.SearchRepository(&models.SearchRepoOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
Page: page,
PageSize: opts.PageSize,
},
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
RenderUserSearch(ctx, &models.SearchUserOptions{
Actor: ctx.User,
Type: models.UserTypeIndividual,
- ListOptions: models.ListOptions{PageSize: setting.UI.ExplorePagingNum},
+ ListOptions: db.ListOptions{PageSize: setting.UI.ExplorePagingNum},
IsActive: util.OptionalBoolTrue,
Visible: []structs.VisibleType{structs.VisibleTypePublic, structs.VisibleTypeLimited, structs.VisibleTypePrivate},
}, tplExploreUsers)
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/markup"
err error
)
repos, count, err = models.SearchRepository(&models.SearchRepoOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: setting.UI.User.RepoPagingNum,
Page: page,
},
var opts = &models.FindOrgMembersOpts{
OrgID: org.ID,
PublicOnly: true,
- ListOptions: models.ListOptions{Page: 1, PageSize: 25},
+ ListOptions: db.ListOptions{Page: 1, PageSize: 25},
}
if ctx.User != nil {
// RetrieveLabels find all the labels of an organization
func RetrieveLabels(ctx *context.Context) {
- labels, err := models.GetLabelsByOrgID(ctx.Org.Organization.ID, ctx.FormString("sort"), models.ListOptions{})
+ labels, err := models.GetLabelsByOrgID(ctx.Org.Organization.ID, ctx.FormString("sort"), db.ListOptions{})
if err != nil {
ctx.ServerError("RetrieveLabels.GetLabels", err)
return
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
// update forks visibility
if visibilityChanged {
- if err := org.GetRepositories(models.ListOptions{Page: 1, PageSize: org.NumRepos}); err != nil {
+ if err := org.GetRepositories(db.ListOptions{Page: 1, PageSize: org.NumRepos}); err != nil {
ctx.ServerError("GetRepositories", err)
return
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/charset"
"code.gitea.io/gitea/modules/context"
commitID = commit.ID.String()
}
- statuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, commitID, models.ListOptions{})
+ statuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, commitID, db.ListOptions{})
if err != nil {
log.Error("GetLatestCommitStatus: %v", err)
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/convert"
issues = []*models.Issue{}
} else {
issues, err = models.Issues(&models.IssuesOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
Page: pager.Paginater.Current(),
PageSize: setting.UI.IssuePagingNum,
},
return
}
- labels, err := models.GetLabelsByRepoID(repo.ID, "", models.ListOptions{})
+ labels, err := models.GetLabelsByRepoID(repo.ID, "", db.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByRepoID", err)
return
}
if repo.Owner.IsOrganization() {
- orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{})
+ orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), db.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByOrgID", err)
return
return nil
}
- labels, err := models.GetLabelsByRepoID(repo.ID, "", models.ListOptions{})
+ labels, err := models.GetLabelsByRepoID(repo.ID, "", db.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByRepoID", err)
return nil
}
ctx.Data["Labels"] = labels
if repo.Owner.IsOrganization() {
- orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{})
+ orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), db.ListOptions{})
if err != nil {
return nil
}
ctx.Data[issueTemplateTitleKey] = meta.Title
ctx.Data[ctxDataKey] = templateBody
labelIDs := make([]string, 0, len(meta.Labels))
- if repoLabels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, "", models.ListOptions{}); err == nil {
+ if repoLabels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, "", db.ListOptions{}); err == nil {
ctx.Data["Labels"] = repoLabels
if ctx.Repo.Owner.IsOrganization() {
- if orgLabels, err := models.GetLabelsByOrgID(ctx.Repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{}); err == nil {
+ if orgLabels, err := models.GetLabelsByOrgID(ctx.Repo.Owner.ID, ctx.FormString("sort"), db.ListOptions{}); err == nil {
ctx.Data["OrgLabels"] = orgLabels
repoLabels = append(repoLabels, orgLabels...)
}
for i := range issue.Labels {
labelIDMark[issue.Labels[i].ID] = true
}
- labels, err := models.GetLabelsByRepoID(repo.ID, "", models.ListOptions{})
+ labels, err := models.GetLabelsByRepoID(repo.ID, "", db.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByRepoID", err)
return
ctx.Data["Labels"] = labels
if repo.Owner.IsOrganization() {
- orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{})
+ orgLabels, err := models.GetLabelsByOrgID(repo.Owner.ID, ctx.FormString("sort"), db.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByOrgID", err)
return
// RetrieveLabels find all the labels of a repository and organization
func RetrieveLabels(ctx *context.Context) {
- labels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, ctx.FormString("sort"), models.ListOptions{})
+ labels, err := models.GetLabelsByRepoID(ctx.Repo.Repository.ID, ctx.FormString("sort"), db.ListOptions{})
if err != nil {
ctx.ServerError("RetrieveLabels.GetLabels", err)
return
ctx.Data["Labels"] = labels
if ctx.Repo.Owner.IsOrganization() {
- orgLabels, err := models.GetLabelsByOrgID(ctx.Repo.Owner.ID, ctx.FormString("sort"), models.ListOptions{})
+ orgLabels, err := models.GetLabelsByOrgID(ctx.Repo.Owner.ID, ctx.FormString("sort"), db.ListOptions{})
if err != nil {
ctx.ServerError("GetLabelsByOrgID", err)
return
"time"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/markup"
}
miles, total, err := models.GetMilestones(models.GetMilestonesOption{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
Page: page,
PageSize: setting.UI.IssuePagingNum,
},
"time"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/git"
if len(compareInfo.Commits) != 0 {
sha := compareInfo.Commits[0].ID.String()
- commitStatuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, sha, models.ListOptions{})
+ commitStatuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, sha, db.ListOptions{})
if err != nil {
ctx.ServerError("GetLatestCommitStatus", err)
return nil
ctx.ServerError(fmt.Sprintf("GetRefCommitID(%s)", pull.GetGitRefName()), err)
return nil
}
- commitStatuses, err := models.GetLatestCommitStatus(repo.ID, sha, models.ListOptions{})
+ commitStatuses, err := models.GetLatestCommitStatus(repo.ID, sha, db.ListOptions{})
if err != nil {
ctx.ServerError("GetLatestCommitStatus", err)
return nil
return nil
}
- commitStatuses, err := models.GetLatestCommitStatus(repo.ID, sha, models.ListOptions{})
+ commitStatuses, err := models.GetLatestCommitStatus(repo.ID, sha, db.ListOptions{})
if err != nil {
ctx.ServerError("GetLatestCommitStatus", err)
return nil
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
ctx.Data["PageIsTagList"] = false
}
- listOptions := models.ListOptions{
+ listOptions := db.ListOptions{
Page: ctx.FormInt("page"),
PageSize: ctx.FormInt("limit"),
}
"time"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/git"
ctx.Data["Title"] = ctx.Tr("repo.settings")
ctx.Data["PageIsSettingsCollaboration"] = true
- users, err := ctx.Repo.Repository.GetCollaborators(models.ListOptions{})
+ users, err := ctx.Repo.Repository.GetCollaborators(db.ListOptions{})
if err != nil {
ctx.ServerError("GetCollaborators", err)
return
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/cache"
"code.gitea.io/gitea/modules/charset"
ctx.Data["LatestCommitUser"] = models.ValidateCommitWithEmail(latestCommit)
- statuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, ctx.Repo.Commit.ID.String(), models.ListOptions{})
+ statuses, err := models.GetLatestCommitStatus(ctx.Repo.Repository.ID, ctx.Repo.Commit.ID.String(), db.ListOptions{})
if err != nil {
log.Error("GetLatestCommitStatus: %v", err)
}
}
// RenderUserCards render a page show users according the input template
-func RenderUserCards(ctx *context.Context, total int, getter func(opts models.ListOptions) ([]*models.User, error), tpl base.TplName) {
+func RenderUserCards(ctx *context.Context, total int, getter func(opts db.ListOptions) ([]*models.User, error), tpl base.TplName) {
page := ctx.FormInt("page")
if page <= 0 {
page = 1
pager := context.NewPagination(total, models.ItemsPerPage, page, 5)
ctx.Data["Page"] = pager
- items, err := getter(models.ListOptions{
+ items, err := getter(db.ListOptions{
Page: pager.Paginater.Current(),
PageSize: models.ItemsPerPage,
})
ctx.Data["Title"] = ctx.Tr("repos.forks")
// TODO: need pagination
- forks, err := ctx.Repo.Repository.GetForks(models.ListOptions{})
+ forks, err := ctx.Repo.Repository.GetForks(db.ListOptions{})
if err != nil {
ctx.ServerError("GetForks", err)
return
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/eventsource"
ctx.Data["SignInLink"] = setting.AppSubURL + "/user/login"
ctx.Data["PageIsSignIn"] = true
ctx.Data["PageIsLogin"] = true
- ctx.Data["EnableSSPI"] = models.IsSSPIEnabled()
+ ctx.Data["EnableSSPI"] = login.IsSSPIEnabled()
ctx.HTML(http.StatusOK, tplSignIn)
}
ctx.Data["SignInLink"] = setting.AppSubURL + "/user/login"
ctx.Data["PageIsSignIn"] = true
ctx.Data["PageIsLogin"] = true
- ctx.Data["EnableSSPI"] = models.IsSSPIEnabled()
+ ctx.Data["EnableSSPI"] = login.IsSSPIEnabled()
if ctx.HasError() {
ctx.HTML(http.StatusOK, tplSignIn)
func SignInOAuth(ctx *context.Context) {
provider := ctx.Params(":provider")
- loginSource, err := models.GetActiveOAuth2LoginSourceByName(provider)
+ loginSource, err := login.GetActiveOAuth2LoginSourceByName(provider)
if err != nil {
ctx.ServerError("SignIn", err)
return
provider := ctx.Params(":provider")
// first look if the provider is still active
- loginSource, err := models.GetActiveOAuth2LoginSourceByName(provider)
+ loginSource, err := login.GetActiveOAuth2LoginSourceByName(provider)
if err != nil {
ctx.ServerError("SignIn", err)
return
FullName: gothUser.Name,
Email: gothUser.Email,
IsActive: !setting.OAuth2Client.RegisterEmailConfirm,
- LoginType: models.LoginOAuth2,
+ LoginType: login.OAuth2,
LoginSource: loginSource.ID,
LoginName: gothUser.UserID,
}
}
}
-func handleOAuth2SignIn(ctx *context.Context, source *models.LoginSource, u *models.User, gothUser goth.User) {
+func handleOAuth2SignIn(ctx *context.Context, source *login.Source, u *models.User, gothUser goth.User) {
updateAvatarIfNeed(gothUser.AvatarURL, u)
needs2FA := false
// OAuth2UserLoginCallback attempts to handle the callback from the OAuth2 provider and if successful
// login the user
-func oAuth2UserLoginCallback(loginSource *models.LoginSource, request *http.Request, response http.ResponseWriter) (*models.User, goth.User, error) {
+func oAuth2UserLoginCallback(loginSource *login.Source, request *http.Request, response http.ResponseWriter) (*models.User, goth.User, error) {
gothUser, err := loginSource.Cfg.(*oauth2.Source).Callback(request, response)
if err != nil {
if err.Error() == "securecookie: the value is too long" {
user := &models.User{
LoginName: gothUser.UserID,
- LoginType: models.LoginOAuth2,
+ LoginType: login.OAuth2,
LoginSource: loginSource.ID,
}
}
}
- loginSource, err := models.GetActiveOAuth2LoginSourceByName(gothUser.Provider)
+ loginSource, err := login.GetActiveOAuth2LoginSourceByName(gothUser.Provider)
if err != nil {
ctx.ServerError("CreateUser", err)
}
Email: form.Email,
Passwd: form.Password,
IsActive: !(setting.Service.RegisterEmailConfirm || setting.Service.RegisterManualConfirm),
- LoginType: models.LoginOAuth2,
+ LoginType: login.OAuth2,
LoginSource: loginSource.ID,
LoginName: gothUser.UserID,
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
issue_indexer "code.gitea.io/gitea/modules/indexer/issues"
// ShowSSHKeys output all the ssh keys of user by uid
func ShowSSHKeys(ctx *context.Context, uid int64) {
- keys, err := models.ListPublicKeys(uid, models.ListOptions{})
+ keys, err := models.ListPublicKeys(uid, db.ListOptions{})
if err != nil {
ctx.ServerError("ListPublicKeys", err)
return
// ShowGPGKeys output all the public GPG keys of user by uid
func ShowGPGKeys(ctx *context.Context, uid int64) {
- keys, err := models.ListGPGKeys(uid, models.ListOptions{})
+ keys, err := models.ListGPGKeys(uid, db.ListOptions{})
if err != nil {
ctx.ServerError("ListGPGKeys", err)
return
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/json"
IDToken string `json:"id_token,omitempty"`
}
-func newAccessTokenResponse(grant *models.OAuth2Grant, serverKey, clientKey oauth2.JWTSigningKey) (*AccessTokenResponse, *AccessTokenError) {
+func newAccessTokenResponse(grant *login.OAuth2Grant, serverKey, clientKey oauth2.JWTSigningKey) (*AccessTokenResponse, *AccessTokenError) {
if setting.OAuth2.InvalidateRefreshTokens {
if err := grant.IncreaseCounter(); err != nil {
return nil, &AccessTokenError{
// generate OpenID Connect id_token
signedIDToken := ""
if grant.ScopeContains("openid") {
- app, err := models.GetOAuth2ApplicationByID(grant.ApplicationID)
+ app, err := login.GetOAuth2ApplicationByID(grant.ApplicationID)
if err != nil {
return nil, &AccessTokenError{
ErrorCode: AccessTokenErrorCodeInvalidRequest,
token, err := oauth2.ParseToken(form.Token, oauth2.DefaultSigningKey)
if err == nil {
if token.Valid() == nil {
- grant, err := models.GetOAuth2GrantByID(token.GrantID)
+ grant, err := login.GetOAuth2GrantByID(token.GrantID)
if err == nil && grant != nil {
- app, err := models.GetOAuth2ApplicationByID(grant.ApplicationID)
+ app, err := login.GetOAuth2ApplicationByID(grant.ApplicationID)
if err == nil && app != nil {
response.Active = true
response.Scope = grant.Scope
return
}
- app, err := models.GetOAuth2ApplicationByClientID(form.ClientID)
+ app, err := login.GetOAuth2ApplicationByClientID(form.ClientID)
if err != nil {
- if models.IsErrOauthClientIDInvalid(err) {
+ if login.IsErrOauthClientIDInvalid(err) {
handleAuthorizeError(ctx, AuthorizeError{
ErrorCode: ErrorCodeUnauthorizedClient,
ErrorDescription: "Client ID not registered",
ctx.ServerError("GetOAuth2ApplicationByClientID", err)
return
}
- if err := app.LoadUser(); err != nil {
- ctx.ServerError("LoadUser", err)
+
+ user, err := models.GetUserByID(app.UID)
+ if err != nil {
+ ctx.ServerError("GetUserByID", err)
return
}
ctx.Data["State"] = form.State
ctx.Data["Scope"] = form.Scope
ctx.Data["Nonce"] = form.Nonce
- ctx.Data["ApplicationUserLink"] = "<a href=\"" + html.EscapeString(setting.AppURL) + html.EscapeString(url.PathEscape(app.User.LowerName)) + "\">@" + html.EscapeString(app.User.Name) + "</a>"
+ ctx.Data["ApplicationUserLink"] = "<a href=\"" + html.EscapeString(setting.AppURL) + html.EscapeString(url.PathEscape(user.LowerName)) + "\">@" + html.EscapeString(user.Name) + "</a>"
ctx.Data["ApplicationRedirectDomainHTML"] = "<strong>" + html.EscapeString(form.RedirectURI) + "</strong>"
// TODO document SESSION <=> FORM
err = ctx.Session.Set("client_id", app.ClientID)
ctx.Error(http.StatusBadRequest)
return
}
- app, err := models.GetOAuth2ApplicationByClientID(form.ClientID)
+ app, err := login.GetOAuth2ApplicationByClientID(form.ClientID)
if err != nil {
ctx.ServerError("GetOAuth2ApplicationByClientID", err)
return
return
}
// get grant before increasing counter
- grant, err := models.GetOAuth2GrantByID(token.GrantID)
+ grant, err := login.GetOAuth2GrantByID(token.GrantID)
if err != nil || grant == nil {
handleAccessTokenError(ctx, AccessTokenError{
ErrorCode: AccessTokenErrorCodeInvalidGrant,
}
func handleAuthorizationCode(ctx *context.Context, form forms.AccessTokenForm, serverKey, clientKey oauth2.JWTSigningKey) {
- app, err := models.GetOAuth2ApplicationByClientID(form.ClientID)
+ app, err := login.GetOAuth2ApplicationByClientID(form.ClientID)
if err != nil {
handleAccessTokenError(ctx, AccessTokenError{
ErrorCode: AccessTokenErrorCodeInvalidClient,
})
return
}
- authorizationCode, err := models.GetOAuth2AuthorizationByCode(form.Code)
+ authorizationCode, err := login.GetOAuth2AuthorizationByCode(form.Code)
if err != nil || authorizationCode == nil {
handleAccessTokenError(ctx, AccessTokenError{
ErrorCode: AccessTokenErrorCodeUnauthorizedClient,
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth/source/oauth2"
"github.com/golang-jwt/jwt"
"github.com/stretchr/testify/assert"
)
-func createAndParseToken(t *testing.T, grant *models.OAuth2Grant) *oauth2.OIDCToken {
+func createAndParseToken(t *testing.T, grant *login.OAuth2Grant) *oauth2.OIDCToken {
signingKey, err := oauth2.CreateJWTSigningKey("HS256", make([]byte, 32))
assert.NoError(t, err)
assert.NotNil(t, signingKey)
func TestNewAccessTokenResponse_OIDCToken(t *testing.T) {
assert.NoError(t, db.PrepareTestDatabase())
- grants, err := models.GetOAuth2GrantsByUserID(3)
+ grants, err := login.GetOAuth2GrantsByUserID(3)
assert.NoError(t, err)
assert.Len(t, grants, 1)
assert.False(t, oidcToken.EmailVerified)
user := db.AssertExistsAndLoadBean(t, &models.User{ID: 5}).(*models.User)
- grants, err = models.GetOAuth2GrantsByUserID(user.ID)
+ grants, err = login.GetOAuth2GrantsByUserID(user.ID)
assert.NoError(t, err)
assert.Len(t, grants, 1)
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/markup"
"code.gitea.io/gitea/modules/markup/markdown"
ctx.Data["Keyword"] = keyword
switch tab {
case "followers":
- items, err := ctxUser.GetFollowers(models.ListOptions{
+ items, err := ctxUser.GetFollowers(db.ListOptions{
PageSize: setting.UI.User.RepoPagingNum,
Page: page,
})
total = ctxUser.NumFollowers
case "following":
- items, err := ctxUser.GetFollowing(models.ListOptions{
+ items, err := ctxUser.GetFollowing(db.ListOptions{
PageSize: setting.UI.User.RepoPagingNum,
Page: page,
})
case "stars":
ctx.Data["PageIsProfileStarList"] = true
repos, count, err = models.SearchRepository(&models.SearchRepoOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: setting.UI.User.RepoPagingNum,
Page: page,
},
}
case "watching":
repos, count, err = models.SearchRepository(&models.SearchRepoOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: setting.UI.User.RepoPagingNum,
Page: page,
},
total = int(count)
default:
repos, count, err = models.SearchRepository(&models.SearchRepoOptions{
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: setting.UI.User.RepoPagingNum,
Page: page,
},
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
ctx.Data["Tokens"] = tokens
ctx.Data["EnableOAuth2"] = setting.OAuth2.Enable
if setting.OAuth2.Enable {
- ctx.Data["Applications"], err = models.GetOAuth2ApplicationsByUserID(ctx.User.ID)
+ ctx.Data["Applications"], err = login.GetOAuth2ApplicationsByUserID(ctx.User.ID)
if err != nil {
ctx.ServerError("GetOAuth2ApplicationsByUserID", err)
return
}
- ctx.Data["Grants"], err = models.GetOAuth2GrantsByUserID(ctx.User.ID)
+ ctx.Data["Grants"], err = login.GetOAuth2GrantsByUserID(ctx.User.ID)
if err != nil {
ctx.ServerError("GetOAuth2GrantsByUserID", err)
return
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
}
func loadKeysData(ctx *context.Context) {
- keys, err := models.ListPublicKeys(ctx.User.ID, models.ListOptions{})
+ keys, err := models.ListPublicKeys(ctx.User.ID, db.ListOptions{})
if err != nil {
ctx.ServerError("ListPublicKeys", err)
return
}
ctx.Data["ExternalKeys"] = externalKeys
- gpgkeys, err := models.ListGPGKeys(ctx.User.ID, models.ListOptions{})
+ gpgkeys, err := models.ListGPGKeys(ctx.User.ID, db.ListOptions{})
if err != nil {
ctx.ServerError("ListGPGKeys", err)
return
// generate a new aes cipher using the csrfToken
ctx.Data["TokenToSign"] = tokenToSign
- principals, err := models.ListPrincipalKeys(ctx.User.ID, models.ListOptions{})
+ principals, err := models.ListPrincipalKeys(ctx.User.ID, db.ListOptions{})
if err != nil {
ctx.ServerError("ListPrincipalKeys", err)
return
"fmt"
"net/http"
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
return
}
// TODO validate redirect URI
- app, err := models.CreateOAuth2Application(models.CreateOAuth2ApplicationOptions{
+ app, err := login.CreateOAuth2Application(login.CreateOAuth2ApplicationOptions{
Name: form.Name,
RedirectURIs: []string{form.RedirectURI},
UserID: ctx.User.ID,
}
// TODO validate redirect URI
var err error
- if ctx.Data["App"], err = models.UpdateOAuth2Application(models.UpdateOAuth2ApplicationOptions{
+ if ctx.Data["App"], err = login.UpdateOAuth2Application(login.UpdateOAuth2ApplicationOptions{
ID: ctx.ParamsInt64("id"),
Name: form.Name,
RedirectURIs: []string{form.RedirectURI},
ctx.Data["Title"] = ctx.Tr("settings")
ctx.Data["PageIsSettingsApplications"] = true
- app, err := models.GetOAuth2ApplicationByID(ctx.ParamsInt64("id"))
+ app, err := login.GetOAuth2ApplicationByID(ctx.ParamsInt64("id"))
if err != nil {
- if models.IsErrOAuthApplicationNotFound(err) {
+ if login.IsErrOAuthApplicationNotFound(err) {
ctx.NotFound("Application not found", err)
return
}
// OAuth2ApplicationShow displays the given application
func OAuth2ApplicationShow(ctx *context.Context) {
- app, err := models.GetOAuth2ApplicationByID(ctx.ParamsInt64("id"))
+ app, err := login.GetOAuth2ApplicationByID(ctx.ParamsInt64("id"))
if err != nil {
- if models.IsErrOAuthApplicationNotFound(err) {
+ if login.IsErrOAuthApplicationNotFound(err) {
ctx.NotFound("Application not found", err)
return
}
// DeleteOAuth2Application deletes the given oauth2 application
func DeleteOAuth2Application(ctx *context.Context) {
- if err := models.DeleteOAuth2Application(ctx.FormInt64("id"), ctx.User.ID); err != nil {
+ if err := login.DeleteOAuth2Application(ctx.FormInt64("id"), ctx.User.ID); err != nil {
ctx.ServerError("DeleteOAuth2Application", err)
return
}
ctx.ServerError("RevokeOAuth2Grant", fmt.Errorf("user id or grant id is zero"))
return
}
- if err := models.RevokeOAuth2Grant(ctx.FormInt64("id"), ctx.User.ID); err != nil {
+ if err := login.RevokeOAuth2Grant(ctx.FormInt64("id"), ctx.User.ID); err != nil {
ctx.ServerError("RevokeOAuth2Grant", err)
return
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/log"
ctx.Data["allowAdopt"] = ctx.IsUserSiteAdmin() || setting.Repository.AllowAdoptionOfUnadoptedRepositories
ctx.Data["allowDelete"] = ctx.IsUserSiteAdmin() || setting.Repository.AllowDeleteOfUnadoptedRepositories
- opts := models.ListOptions{
+ opts := db.ListOptions{
PageSize: setting.UI.Admin.UserPagingNum,
Page: ctx.FormInt("page"),
}
return
}
- if err := ctxUser.GetRepositories(models.ListOptions{Page: 1, PageSize: setting.UI.Admin.UserPagingNum}, repoNames...); err != nil {
+ if err := ctxUser.GetRepositories(db.ListOptions{Page: 1, PageSize: setting.UI.Admin.UserPagingNum}, repoNames...); err != nil {
ctx.ServerError("GetRepositories", err)
return
}
"net/http"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/context"
"code.gitea.io/gitea/modules/setting"
}
// map the provider display name with the LoginSource
- sources := make(map[*models.LoginSource]string)
+ sources := make(map[*login.Source]string)
for _, externalAccount := range accountLinks {
- if loginSource, err := models.GetLoginSourceByID(externalAccount.LoginSourceID); err == nil {
+ if loginSource, err := login.GetSourceByID(externalAccount.LoginSourceID); err == nil {
var providerDisplayName string
type DisplayNamed interface {
--- /dev/null
+// Copyright 2021 The Gitea Authors. All rights reserved.
+// Use of this source code is governed by a MIT-style
+// license that can be found in the LICENSE file.
+
+package auth
+
+import (
+ "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
+)
+
+// DeleteLoginSource deletes a LoginSource record in DB.
+func DeleteLoginSource(source *login.Source) error {
+ count, err := db.GetEngine(db.DefaultContext).Count(&models.User{LoginSource: source.ID})
+ if err != nil {
+ return err
+ } else if count > 0 {
+ return login.ErrSourceInUse{
+ ID: source.ID,
+ }
+ }
+
+ count, err = db.GetEngine(db.DefaultContext).Count(&models.ExternalLoginUser{LoginSourceID: source.ID})
+ if err != nil {
+ return err
+ } else if count > 0 {
+ return login.ErrSourceInUse{
+ ID: source.ID,
+ }
+ }
+
+ if registerableSource, ok := source.Cfg.(login.RegisterableSource); ok {
+ if err := registerableSource.UnregisterSource(); err != nil {
+ return err
+ }
+ }
+
+ _, err = db.GetEngine(db.DefaultContext).ID(source.ID).Delete(new(login.Source))
+ return err
+}
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/timeutil"
"code.gitea.io/gitea/modules/web/middleware"
log.Trace("oauth2.ParseToken: %v", err)
return 0
}
- var grant *models.OAuth2Grant
- if grant, err = models.GetOAuth2GrantByID(token.GrantID); err != nil || grant == nil {
+ var grant *login.OAuth2Grant
+ if grant, err = login.GetOAuth2GrantByID(token.GrantID); err != nil || grant == nil {
return 0
}
if token.Type != oauth2.TypeAccessToken {
"code.gitea.io/gitea/models"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/log"
// Register the sources
)
// UserSignIn validates user name and password.
-func UserSignIn(username, password string) (*models.User, *models.LoginSource, error) {
+func UserSignIn(username, password string) (*models.User, *login.Source, error) {
var user *models.User
if strings.Contains(username, "@") {
user = &models.User{Email: strings.ToLower(strings.TrimSpace(username))}
}
if hasUser {
- source, err := models.GetLoginSourceByID(user.LoginSource)
+ source, err := login.GetSourceByID(user.LoginSource)
if err != nil {
return nil, nil, err
}
return user, source, nil
}
- sources, err := models.AllActiveLoginSources()
+ sources, err := login.AllActiveSources()
if err != nil {
return nil, nil, err
}
package db_test
import (
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth"
"code.gitea.io/gitea/services/auth/source/db"
)
type sourceInterface interface {
auth.PasswordAuthenticator
- models.LoginConfig
+ login.Config
}
var _ (sourceInterface) = &db.Source{}
package db
-import "code.gitea.io/gitea/models"
+import (
+ "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
+)
// Source is a password authentication service
type Source struct{}
}
func init() {
- models.RegisterLoginTypeConfig(models.LoginNoType, &Source{})
- models.RegisterLoginTypeConfig(models.LoginPlain, &Source{})
+ login.RegisterTypeConfig(login.NoType, &Source{})
+ login.RegisterTypeConfig(login.Plain, &Source{})
}
package ldap_test
import (
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth"
"code.gitea.io/gitea/services/auth/source/ldap"
)
auth.PasswordAuthenticator
auth.SynchronizableSource
auth.LocalTwoFASkipper
- models.SSHKeyProvider
- models.LoginConfig
- models.SkipVerifiable
- models.HasTLSer
- models.UseTLSer
- models.LoginSourceSettable
+ login.SSHKeyProvider
+ login.Config
+ login.SkipVerifiable
+ login.HasTLSer
+ login.UseTLSer
+ login.SourceSettable
}
var _ (sourceInterface) = &ldap.Source{}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/json"
"code.gitea.io/gitea/modules/secret"
"code.gitea.io/gitea/modules/setting"
SkipLocalTwoFA bool // Skip Local 2fa for users authenticated with this source
// reference to the loginSource
- loginSource *models.LoginSource
+ loginSource *login.Source
}
// FromDB fills up a LDAPConfig from serialized format.
}
// SetLoginSource sets the related LoginSource
-func (source *Source) SetLoginSource(loginSource *models.LoginSource) {
+func (source *Source) SetLoginSource(loginSource *login.Source) {
source.loginSource = loginSource
}
func init() {
- models.RegisterLoginTypeConfig(models.LoginLDAP, &Source{})
- models.RegisterLoginTypeConfig(models.LoginDLDAP, &Source{})
+ login.RegisterTypeConfig(login.LDAP, &Source{})
+ login.RegisterTypeConfig(login.DLDAP, &Source{})
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/mailer"
)
// Authenticate queries if login/password is valid against the LDAP directory pool,
// and create a local user if success when enabled.
-func (source *Source) Authenticate(user *models.User, login, password string) (*models.User, error) {
- sr := source.SearchEntry(login, password, source.loginSource.Type == models.LoginDLDAP)
+func (source *Source) Authenticate(user *models.User, userName, password string) (*models.User, error) {
+ sr := source.SearchEntry(userName, password, source.loginSource.Type == login.DLDAP)
if sr == nil {
// User not in LDAP, do nothing
- return nil, models.ErrUserNotExist{Name: login}
+ return nil, models.ErrUserNotExist{Name: userName}
}
isAttributeSSHPublicKeySet := len(strings.TrimSpace(source.AttributeSSHPublicKey)) > 0
// Fallback.
if len(sr.Username) == 0 {
- sr.Username = login
+ sr.Username = userName
}
if len(sr.Mail) == 0 {
Email: sr.Mail,
LoginType: source.loginSource.Type,
LoginSource: source.loginSource.ID,
- LoginName: login,
+ LoginName: userName,
IsActive: true,
IsAdmin: sr.IsAdmin,
IsRestricted: sr.IsRestricted,
package oauth2_test
import (
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth"
"code.gitea.io/gitea/services/auth/source/oauth2"
)
// It tightly binds the interfaces and implementation without breaking go import cycles
type sourceInterface interface {
- models.LoginConfig
- models.LoginSourceSettable
- models.RegisterableSource
+ login.Config
+ login.SourceSettable
+ login.RegisterableSource
auth.PasswordAuthenticator
}
"net/http"
"sync"
- "code.gitea.io/gitea/models"
"code.gitea.io/gitea/models/db"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
// initOAuth2LoginSources is used to load and register all active OAuth2 providers
func initOAuth2LoginSources() error {
- loginSources, _ := models.GetActiveOAuth2ProviderLoginSources()
+ loginSources, _ := login.GetActiveOAuth2ProviderLoginSources()
for _, source := range loginSources {
oauth2Source, ok := source.Cfg.(*Source)
if !ok {
"sort"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
func GetActiveOAuth2Providers() ([]string, map[string]Provider, error) {
// Maybe also separate used and unused providers so we can force the registration of only 1 active provider for each type
- loginSources, err := models.GetActiveOAuth2ProviderLoginSources()
+ loginSources, err := login.GetActiveOAuth2ProviderLoginSources()
if err != nil {
return nil, nil, err
}
import (
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/json"
)
SkipLocalTwoFA bool
// reference to the loginSource
- loginSource *models.LoginSource
+ loginSource *login.Source
}
// FromDB fills up an OAuth2Config from serialized format.
}
// SetLoginSource sets the related LoginSource
-func (source *Source) SetLoginSource(loginSource *models.LoginSource) {
+func (source *Source) SetLoginSource(loginSource *login.Source) {
source.loginSource = loginSource
}
func init() {
- models.RegisterLoginTypeConfig(models.LoginOAuth2, &Source{})
+ login.RegisterTypeConfig(login.OAuth2, &Source{})
}
package pam_test
import (
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth"
"code.gitea.io/gitea/services/auth/source/pam"
)
type sourceInterface interface {
auth.PasswordAuthenticator
- models.LoginConfig
- models.LoginSourceSettable
+ login.Config
+ login.SourceSettable
}
var _ (sourceInterface) = &pam.Source{}
import (
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/json"
)
EmailDomain string
// reference to the loginSource
- loginSource *models.LoginSource
+ loginSource *login.Source
}
// FromDB fills up a PAMConfig from serialized format.
}
// SetLoginSource sets the related LoginSource
-func (source *Source) SetLoginSource(loginSource *models.LoginSource) {
+func (source *Source) SetLoginSource(loginSource *login.Source) {
source.loginSource = loginSource
}
func init() {
- models.RegisterLoginTypeConfig(models.LoginPAM, &Source{})
+ login.RegisterTypeConfig(login.PAM, &Source{})
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/auth/pam"
"code.gitea.io/gitea/modules/setting"
"code.gitea.io/gitea/services/mailer"
// Authenticate queries if login/password is valid against the PAM,
// and create a local user if success when enabled.
-func (source *Source) Authenticate(user *models.User, login, password string) (*models.User, error) {
- pamLogin, err := pam.Auth(source.ServiceName, login, password)
+func (source *Source) Authenticate(user *models.User, userName, password string) (*models.User, error) {
+ pamLogin, err := pam.Auth(source.ServiceName, userName, password)
if err != nil {
if strings.Contains(err.Error(), "Authentication failure") {
- return nil, models.ErrUserNotExist{Name: login}
+ return nil, models.ErrUserNotExist{Name: userName}
}
return nil, err
}
Name: username,
Email: email,
Passwd: password,
- LoginType: models.LoginPAM,
+ LoginType: login.PAM,
LoginSource: source.loginSource.ID,
- LoginName: login, // This is what the user typed in
+ LoginName: userName, // This is what the user typed in
IsActive: true,
}
package smtp_test
import (
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth"
"code.gitea.io/gitea/services/auth/source/smtp"
)
type sourceInterface interface {
auth.PasswordAuthenticator
- models.LoginConfig
- models.SkipVerifiable
- models.HasTLSer
- models.UseTLSer
- models.LoginSourceSettable
+ login.Config
+ login.SkipVerifiable
+ login.HasTLSer
+ login.UseTLSer
+ login.SourceSettable
}
var _ (sourceInterface) = &smtp.Source{}
import (
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/json"
)
DisableHelo bool
// reference to the loginSource
- loginSource *models.LoginSource
+ loginSource *login.Source
}
// FromDB fills up an SMTPConfig from serialized format.
}
// SetLoginSource sets the related LoginSource
-func (source *Source) SetLoginSource(loginSource *models.LoginSource) {
+func (source *Source) SetLoginSource(loginSource *login.Source) {
source.loginSource = loginSource
}
func init() {
- models.RegisterLoginTypeConfig(models.LoginSMTP, &Source{})
+ login.RegisterTypeConfig(login.SMTP, &Source{})
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/util"
"code.gitea.io/gitea/services/mailer"
)
// Authenticate queries if the provided login/password is authenticates against the SMTP server
// Users will be autoregistered as required
-func (source *Source) Authenticate(user *models.User, login, password string) (*models.User, error) {
+func (source *Source) Authenticate(user *models.User, userName, password string) (*models.User, error) {
// Verify allowed domains.
if len(source.AllowedDomains) > 0 {
- idx := strings.Index(login, "@")
+ idx := strings.Index(userName, "@")
if idx == -1 {
- return nil, models.ErrUserNotExist{Name: login}
- } else if !util.IsStringInSlice(login[idx+1:], strings.Split(source.AllowedDomains, ","), true) {
- return nil, models.ErrUserNotExist{Name: login}
+ return nil, models.ErrUserNotExist{Name: userName}
+ } else if !util.IsStringInSlice(userName[idx+1:], strings.Split(source.AllowedDomains, ","), true) {
+ return nil, models.ErrUserNotExist{Name: userName}
}
}
var auth smtp.Auth
switch source.Auth {
case PlainAuthentication:
- auth = smtp.PlainAuth("", login, password, source.Host)
+ auth = smtp.PlainAuth("", userName, password, source.Host)
case LoginAuthentication:
- auth = &loginAuthenticator{login, password}
+ auth = &loginAuthenticator{userName, password}
case CRAMMD5Authentication:
- auth = smtp.CRAMMD5Auth(login, password)
+ auth = smtp.CRAMMD5Auth(userName, password)
default:
return nil, errors.New("unsupported SMTP auth type")
}
tperr, ok := err.(*textproto.Error)
if (ok && tperr.Code == 535) ||
strings.Contains(err.Error(), "Username and Password not accepted") {
- return nil, models.ErrUserNotExist{Name: login}
+ return nil, models.ErrUserNotExist{Name: userName}
}
if (ok && tperr.Code == 534) ||
strings.Contains(err.Error(), "Application-specific password required") {
- return nil, models.ErrUserNotExist{Name: login}
+ return nil, models.ErrUserNotExist{Name: userName}
}
return nil, err
}
return user, nil
}
- username := login
- idx := strings.Index(login, "@")
+ username := userName
+ idx := strings.Index(userName, "@")
if idx > -1 {
- username = login[:idx]
+ username = userName[:idx]
}
user = &models.User{
LowerName: strings.ToLower(username),
Name: strings.ToLower(username),
- Email: login,
+ Email: userName,
Passwd: password,
- LoginType: models.LoginSMTP,
+ LoginType: login.SMTP,
LoginSource: source.loginSource.ID,
- LoginName: login,
+ LoginName: userName,
IsActive: true,
}
package sspi_test
import (
- "code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/services/auth/source/sspi"
)
// It tightly binds the interfaces and implementation without breaking go import cycles
type sourceInterface interface {
- models.LoginConfig
+ login.Config
}
var _ (sourceInterface) = &sspi.Source{}
import (
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/json"
)
}
func init() {
- models.RegisterLoginTypeConfig(models.LoginSSPI, &Source{})
+ login.RegisterTypeConfig(login.SSPI, &Source{})
}
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/base"
"code.gitea.io/gitea/modules/log"
"code.gitea.io/gitea/modules/setting"
// getConfig retrieves the SSPI configuration from login sources
func (s *SSPI) getConfig() (*sspi.Source, error) {
- sources, err := models.ActiveLoginSources(models.LoginSSPI)
+ sources, err := login.ActiveSources(login.SSPI)
if err != nil {
return nil, err
}
// fails (or if negotiation should continue), which would prevent other authentication methods
// to execute at all.
func specialInit() {
- if models.IsSSPIEnabled() {
+ if login.IsSSPIEnabled() {
Register(&SSPI{})
}
}
"context"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/log"
)
func SyncExternalUsers(ctx context.Context, updateExisting bool) error {
log.Trace("Doing: SyncExternalUsers")
- ls, err := models.LoginSources()
+ ls, err := login.Sources()
if err != nil {
log.Error("SyncExternalUsers: %v", err)
return err
"strings"
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/login"
"code.gitea.io/gitea/modules/structs"
"github.com/markbates/goth"
// LinkAccountToUser link the gothUser to the user
func LinkAccountToUser(user *models.User, gothUser goth.User) error {
- loginSource, err := models.GetActiveOAuth2LoginSourceByName(gothUser.Provider)
+ loginSource, err := login.GetActiveOAuth2LoginSourceByName(gothUser.Provider)
if err != nil {
return err
}
import (
"code.gitea.io/gitea/models"
+ "code.gitea.io/gitea/models/db"
"code.gitea.io/gitea/modules/git"
"code.gitea.io/gitea/modules/structs"
return "", errors.Wrap(err, "LoadBaseRepo")
}
- commitStatuses, err := models.GetLatestCommitStatus(pr.BaseRepo.ID, sha, models.ListOptions{})
+ commitStatuses, err := models.GetLatestCommitStatus(pr.BaseRepo.ID, sha, db.ListOptions{})
if err != nil {
return "", errors.Wrap(err, "GetLatestCommitStatus")
}
return nil, err
}
- statusList, err := models.GetLatestCommitStatus(pr.BaseRepo.ID, sha, models.ListOptions{})
+ statusList, err := models.GetLatestCommitStatus(pr.BaseRepo.ID, sha, db.ListOptions{})
if err != nil {
return nil, err
}
Line: line,
TreePath: treePath,
Type: models.CommentTypeCode,
- ListOptions: models.ListOptions{
+ ListOptions: db.ListOptions{
PageSize: 1,
Page: 1,
},