|
|
|
// Copyright 2014 The Gogs Authors. All rights reserved.
|
|
|
|
// Copyright 2018 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 (
|
|
|
|
"context"
|
|
|
|
"database/sql"
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
|
|
|
"reflect"
|
|
|
|
"strings"
|
|
|
|
|
|
|
|
"code.gitea.io/gitea/modules/setting"
|
|
|
|
|
|
|
|
// Needed for the MySQL driver
|
|
|
|
_ "github.com/go-sql-driver/mysql"
|
|
|
|
"xorm.io/xorm"
|
|
|
|
"xorm.io/xorm/names"
|
|
|
|
"xorm.io/xorm/schemas"
|
|
|
|
|
|
|
|
// Needed for the Postgresql driver
|
|
|
|
_ "github.com/lib/pq"
|
|
|
|
|
|
|
|
// Needed for the MSSQL driver
|
|
|
|
_ "github.com/denisenkom/go-mssqldb"
|
|
|
|
)
|
|
|
|
|
|
|
|
// Engine represents a xorm engine or session.
|
|
|
|
type Engine interface {
|
|
|
|
Table(tableNameOrBean interface{}) *xorm.Session
|
|
|
|
Count(...interface{}) (int64, error)
|
|
|
|
Decr(column string, arg ...interface{}) *xorm.Session
|
|
|
|
Delete(interface{}) (int64, error)
|
|
|
|
Exec(...interface{}) (sql.Result, error)
|
|
|
|
Find(interface{}, ...interface{}) error
|
|
|
|
Get(interface{}) (bool, error)
|
|
|
|
ID(interface{}) *xorm.Session
|
|
|
|
In(string, ...interface{}) *xorm.Session
|
|
|
|
Incr(column string, arg ...interface{}) *xorm.Session
|
|
|
|
Insert(...interface{}) (int64, error)
|
|
|
|
InsertOne(interface{}) (int64, error)
|
|
|
|
Iterate(interface{}, xorm.IterFunc) error
|
|
|
|
Join(joinOperator string, tablename interface{}, condition string, args ...interface{}) *xorm.Session
|
|
|
|
SQL(interface{}, ...interface{}) *xorm.Session
|
|
|
|
Where(interface{}, ...interface{}) *xorm.Session
|
|
|
|
Asc(colNames ...string) *xorm.Session
|
|
|
|
Desc(colNames ...string) *xorm.Session
|
|
|
|
Limit(limit int, start ...int) *xorm.Session
|
|
|
|
SumInt(bean interface{}, columnName string) (res int64, err error)
|
|
|
|
}
|
|
|
|
|
|
|
|
const (
|
|
|
|
// When queries are broken down in parts because of the number
|
|
|
|
// of parameters, attempt to break by this amount
|
|
|
|
maxQueryParameters = 300
|
|
|
|
)
|
|
|
|
|
|
|
|
var (
|
|
|
|
x *xorm.Engine
|
|
|
|
tables []interface{}
|
|
|
|
|
|
|
|
// HasEngine specifies if we have a xorm.Engine
|
|
|
|
HasEngine bool
|
|
|
|
)
|
|
|
|
|
|
|
|
func init() {
|
|
|
|
tables = append(tables,
|
|
|
|
new(User),
|
|
|
|
new(PublicKey),
|
|
|
|
new(AccessToken),
|
|
|
|
new(Repository),
|
|
|
|
new(DeployKey),
|
|
|
|
new(Collaboration),
|
|
|
|
new(Access),
|
|
|
|
new(Upload),
|
|
|
|
new(Watch),
|
|
|
|
new(Star),
|
|
|
|
new(Follow),
|
|
|
|
new(Action),
|
|
|
|
new(Issue),
|
|
|
|
new(PullRequest),
|
|
|
|
new(Comment),
|
|
|
|
new(Attachment),
|
|
|
|
new(Label),
|
|
|
|
new(IssueLabel),
|
|
|
|
new(Milestone),
|
|
|
|
new(Mirror),
|
|
|
|
new(Release),
|
|
|
|
new(LoginSource),
|
|
|
|
new(Webhook),
|
|
|
|
new(HookTask),
|
|
|
|
new(Team),
|
|
|
|
new(OrgUser),
|
|
|
|
new(TeamUser),
|
|
|
|
new(TeamRepo),
|
|
|
|
new(Notice),
|
|
|
|
new(EmailAddress),
|
|
|
|
new(Notification),
|
|
|
|
new(IssueUser),
|
|
|
|
new(LFSMetaObject),
|
|
|
|
new(TwoFactor),
|
|
|
|
new(GPGKey),
|
|
|
|
new(GPGKeyImport),
|
|
|
|
new(RepoUnit),
|
|
|
|
new(RepoRedirect),
|
|
|
|
new(ExternalLoginUser),
|
|
|
|
new(ProtectedBranch),
|
|
|
|
new(UserOpenID),
|
|
|
|
new(IssueWatch),
|
|
|
|
new(CommitStatus),
|
|
|
|
new(Stopwatch),
|
|
|
|
new(TrackedTime),
|
|
|
|
new(DeletedBranch),
|
|
|
|
new(RepoIndexerStatus),
|
|
|
|
new(IssueDependency),
|
|
|
|
new(LFSLock),
|
|
|
|
new(Reaction),
|
|
|
|
new(IssueAssignees),
|
|
|
|
new(U2FRegistration),
|
|
|
|
new(TeamUnit),
|
|
|
|
new(Review),
|
|
|
|
new(OAuth2Application),
|
|
|
|
new(OAuth2AuthorizationCode),
|
|
|
|
new(OAuth2Grant),
|
|
|
|
new(Task),
|
|
|
|
new(LanguageStat),
|
|
|
|
new(EmailHash),
|
|
|
|
new(UserRedirect),
|
|
|
|
new(Project),
|
|
|
|
new(ProjectBoard),
|
|
|
|
new(ProjectIssue),
|
|
|
|
new(Session),
|
|
|
|
new(RepoTransfer),
|
feat: Majority Judgment Polls (2020)
Add `Poll` model and `CreatePoll` function.
The poll is ineffective, no one can vote. (yet)
Add `Judgment` creation and update.
There can be at most one judgment per trio of poll, judge and candidate.
Each Judge may emit one Judgment per Candidate of a Poll.
Mop up and oust a reminiscent bug.
Add the Poll Create, Update and Delete forms and logic.
We can't tally a Poll yet.
Nor can we judge issues.
Add the Judgment forms for each Poll of each issue.
Everything works so far without javascript.
We added CSS like monkeys, until we figure out what to do with it.
Use emotes Chromium can print as well.
Fix some warnings.
Prepare for the far future.
Add scoring pseudo-code for fast deliberation.
This was entertaining, but it's perhaps wrong,
although we can't find any reason why so far.
We contacted the world's top specialist on the matter.
…
Three gods, A, B, and C are called,
in no particular order, True, False, and Random.
True always speaks truly, False always speaks falsely,
but whether Random speaks truly or falsely is a
completely random matter.
Your task is to determine the identities of A, B, and C
by asking three yes-no questions; each question
must be put to exactly one god. The gods understand
English, but will answer all questions in
their own language, in which the words for yes
and no are da and ja, in some order.
You do not know which word means which.
Add a naive tallier.
I wish I had a feature suite in Gherkin here…
Add some tests to the deliberator and implement them.
Still waiting for input from the specialist(s)
before delving into implementation details.
Use unsigned integers where it makes sense.
(or not)
Provision more tests for the deliberator.
We've got some answers — still confused, though.
Implement a very naive deliberator.
Fix a fix for the label's hover area.
Let's barf as little as possible on existing CSS.
Fill the missing judgments as REJECT judgments.
This should be optional.
Add a battery of tests to GetMedian
We're now going to be able to implement it properly,
not like the cheap cheat we had so far.
Adapt label color to median grade.
This is a cheap implementation that will probably need a rewrite
for complete support of other gradations.
Add more tests to expose the limitations of the current scoring implementation.
Now we can work some more on the scoring.
Implement a less naive score calculus.
So far it holds.
The score is a bit long (90chars = 15 chars per possible grade)
but it won't get any longer with more judges,
unless we have to go over 500 billion judges.
Fix poll's CRUD subheaders I18N.
Make sure judgments can be emitted with keyboard only.
`:focus-within` <3 U CSS
Add a basic page to view a poll.
Move Poll CSS to LESS.
Clean up.
Tease about what will come next.
Add a repo header nav item for polls.
Ideally this whole thing should be a plugin and not a fork.
Not sure how to add new Db models and Routes.
We'd also need a custom spot in the issue view template,
but that can probably be merged upstream.
Clean up.
We'd love to move the routes to their own file.
And then being able to add them via `custom/`.
Disable event sourcing until /user/events do not hang for a minute,
because it makes browsing gitea rapidly impossible.
Add french translations for the polling UI.
Rename `Judgment` into `PollJudgment`.
After careful consideration, it's probably best to namespace.
Also, explicit is better than implicit. :)
BREAKING CHANGE: Not sure how the migrations will operate here.
This is why it's best to do it now than once we're actually using it.
Tweak the poll's labels for mobile with a CSS media query.
Thanks @pierre-louis for the bug report !
Review.
docs: explicit is better than implicit
chore: "missing" is more explicit than "lost"
feat: add radial merit profiles, in SVG
Ignore the gitea-repositories directory.
chore: clean up the radial merit profile SVG template
test: expose an issue with the tally
The returned amounts for each grade are wrong.
How could this happen, you ask?
Lack of unit-testing, that's why!
(also, shallow copy shenanigans)
chore: spacing
Still experimenting with the spacing in templates.
I know Gitea does not use spaces.
My sight is not getting any better,
and spacing helps a lot.
Yes, I'm already using bigger fonts.
test: refine the tests about the critical bug found
… so that it does not happen again!
fix: elbow grease the copy mechanism to fix The Bug®
fix: hide the description if none is provided.
Should we mention that it is a bad practice ?
It feels like it is. … To deliberate.
chore: review naive deliberator
feat: add the issue title to the list of issues of a poll
Also naive and inefficient, but if we paginate, we'll be ok.
And if not, we can probably improve this by batching the queries.
fix: remove a debugging tweak that was overlooked
Also, remove the need to translate the word `Issue`.
Oddly enough, it is never translated by itself,
it is only in plural form opr inside a sentence.
feat: add the merit profile behind the median grade
Usual CSS woes
- Really not confident about positioning top and left with `em`.
- Z-index shenanigans to skip unexpected offset in positioning,
where the absolute of a child in a relative container
won't point to top left but to bottom of other child in static
(try moving the merit profile below the input.emote, and remove z-indices)
Right now the merit profile is shown to all logged in, whether they judged or not. This is not the intended final behavior. Ideally we'd have settings fdr this.
chore: clean up before the next stage
4 years ago
|
|
|
new(Poll),
|
|
|
|
new(PollJudgment),
|
|
|
|
)
|
|
|
|
|
|
|
|
gonicNames := []string{"SSL", "UID"}
|
|
|
|
for _, name := range gonicNames {
|
|
|
|
names.LintGonicMapper[name] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func getEngine() (*xorm.Engine, error) {
|
|
|
|
connStr, err := setting.DBConnStr()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
var engine *xorm.Engine
|
|
|
|
|
|
|
|
if setting.Database.UsePostgreSQL && len(setting.Database.Schema) > 0 {
|
|
|
|
// OK whilst we sort out our schema issues - create a schema aware postgres
|
|
|
|
registerPostgresSchemaDriver()
|
|
|
|
engine, err = xorm.NewEngine("postgresschema", connStr)
|
|
|
|
} else {
|
|
|
|
engine, err = xorm.NewEngine(setting.Database.Type, connStr)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
if setting.Database.Type == "mysql" {
|
|
|
|
engine.Dialect().SetParams(map[string]string{"rowFormat": "DYNAMIC"})
|
|
|
|
} else if setting.Database.Type == "mssql" {
|
|
|
|
engine.Dialect().SetParams(map[string]string{"DEFAULT_VARCHAR": "nvarchar"})
|
|
|
|
}
|
|
|
|
engine.SetSchema(setting.Database.Schema)
|
|
|
|
return engine, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewTestEngine sets a new test xorm.Engine
|
|
|
|
func NewTestEngine() (err error) {
|
|
|
|
x, err = getEngine()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Connect to database: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
x.SetMapper(names.GonicMapper{})
|
|
|
|
x.SetLogger(NewXORMLogger(!setting.IsProd()))
|
|
|
|
x.ShowSQL(!setting.IsProd())
|
|
|
|
return x.StoreEngine("InnoDB").Sync2(tables...)
|
|
|
|
}
|
|
|
|
|
|
|
|
// SetEngine sets the xorm.Engine
|
|
|
|
func SetEngine() (err error) {
|
|
|
|
x, err = getEngine()
|
|
|
|
if err != nil {
|
|
|
|
return fmt.Errorf("Failed to connect to database: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
x.SetMapper(names.GonicMapper{})
|
|
|
|
// WARNING: for serv command, MUST remove the output to os.stdout,
|
|
|
|
// so use log file to instead print to stdout.
|
|
|
|
x.SetLogger(NewXORMLogger(setting.Database.LogSQL))
|
|
|
|
x.ShowSQL(setting.Database.LogSQL)
|
|
|
|
x.SetMaxOpenConns(setting.Database.MaxOpenConns)
|
|
|
|
x.SetMaxIdleConns(setting.Database.MaxIdleConns)
|
|
|
|
x.SetConnMaxLifetime(setting.Database.ConnMaxLifetime)
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NewEngine initializes a new xorm.Engine
|
|
|
|
// This function must never call .Sync2() if the provided migration function fails.
|
|
|
|
// When called from the "doctor" command, the migration function is a version check
|
|
|
|
// that prevents the doctor from fixing anything in the database if the migration level
|
|
|
|
// is different from the expected value.
|
|
|
|
func NewEngine(ctx context.Context, migrateFunc func(*xorm.Engine) error) (err error) {
|
|
|
|
if err = SetEngine(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
x.SetDefaultContext(ctx)
|
|
|
|
|
|
|
|
if err = x.Ping(); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = migrateFunc(x); err != nil {
|
|
|
|
return fmt.Errorf("migrate: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = x.StoreEngine("InnoDB").Sync2(tables...); err != nil {
|
|
|
|
return fmt.Errorf("sync database struct error: %v", err)
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// NamesToBean return a list of beans or an error
|
|
|
|
func NamesToBean(names ...string) ([]interface{}, error) {
|
|
|
|
beans := []interface{}{}
|
|
|
|
if len(names) == 0 {
|
|
|
|
beans = append(beans, tables...)
|
|
|
|
return beans, nil
|
|
|
|
}
|
|
|
|
// Need to map provided names to beans...
|
|
|
|
beanMap := make(map[string]interface{})
|
|
|
|
for _, bean := range tables {
|
|
|
|
|
|
|
|
beanMap[strings.ToLower(reflect.Indirect(reflect.ValueOf(bean)).Type().Name())] = bean
|
|
|
|
beanMap[strings.ToLower(x.TableName(bean))] = bean
|
|
|
|
beanMap[strings.ToLower(x.TableName(bean, true))] = bean
|
|
|
|
}
|
|
|
|
|
|
|
|
gotBean := make(map[interface{}]bool)
|
|
|
|
for _, name := range names {
|
|
|
|
bean, ok := beanMap[strings.ToLower(strings.TrimSpace(name))]
|
|
|
|
if !ok {
|
|
|
|
return nil, fmt.Errorf("No table found that matches: %s", name)
|
|
|
|
}
|
|
|
|
if !gotBean[bean] {
|
|
|
|
beans = append(beans, bean)
|
|
|
|
gotBean[bean] = true
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return beans, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Statistic contains the database statistics
|
|
|
|
type Statistic struct {
|
|
|
|
Counter struct {
|
|
|
|
User, Org, PublicKey,
|
|
|
|
Repo, Watch, Star, Action, Access,
|
|
|
|
Issue, Comment, Oauth, Follow,
|
|
|
|
Mirror, Release, LoginSource, Webhook,
|
|
|
|
Milestone, Label, HookTask,
|
|
|
|
Team, UpdateTask, Attachment int64
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetStatistic returns the database statistics
|
|
|
|
func GetStatistic() (stats Statistic) {
|
|
|
|
stats.Counter.User = CountUsers()
|
|
|
|
stats.Counter.Org = CountOrganizations()
|
|
|
|
stats.Counter.PublicKey, _ = x.Count(new(PublicKey))
|
|
|
|
stats.Counter.Repo = CountRepositories(true)
|
|
|
|
stats.Counter.Watch, _ = x.Count(new(Watch))
|
|
|
|
stats.Counter.Star, _ = x.Count(new(Star))
|
|
|
|
stats.Counter.Action, _ = x.Count(new(Action))
|
|
|
|
stats.Counter.Access, _ = x.Count(new(Access))
|
|
|
|
stats.Counter.Issue, _ = x.Count(new(Issue))
|
|
|
|
stats.Counter.Comment, _ = x.Count(new(Comment))
|
|
|
|
stats.Counter.Oauth = 0
|
|
|
|
stats.Counter.Follow, _ = x.Count(new(Follow))
|
|
|
|
stats.Counter.Mirror, _ = x.Count(new(Mirror))
|
|
|
|
stats.Counter.Release, _ = x.Count(new(Release))
|
|
|
|
stats.Counter.LoginSource = CountLoginSources()
|
|
|
|
stats.Counter.Webhook, _ = x.Count(new(Webhook))
|
|
|
|
stats.Counter.Milestone, _ = x.Count(new(Milestone))
|
|
|
|
stats.Counter.Label, _ = x.Count(new(Label))
|
|
|
|
stats.Counter.HookTask, _ = x.Count(new(HookTask))
|
|
|
|
stats.Counter.Team, _ = x.Count(new(Team))
|
|
|
|
stats.Counter.Attachment, _ = x.Count(new(Attachment))
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ping tests if database is alive
|
|
|
|
func Ping() error {
|
|
|
|
if x != nil {
|
|
|
|
return x.Ping()
|
|
|
|
}
|
|
|
|
return errors.New("database not configured")
|
|
|
|
}
|
|
|
|
|
|
|
|
// DumpDatabase dumps all data from database according the special database SQL syntax to file system.
|
|
|
|
func DumpDatabase(filePath, dbType string) error {
|
|
|
|
var tbs []*schemas.Table
|
|
|
|
for _, t := range tables {
|
|
|
|
t, err := x.TableInfo(t)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
tbs = append(tbs, t)
|
|
|
|
}
|
|
|
|
|
|
|
|
type Version struct {
|
|
|
|
ID int64 `xorm:"pk autoincr"`
|
|
|
|
Version int64
|
|
|
|
}
|
|
|
|
t, err := x.TableInfo(&Version{})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
tbs = append(tbs, t)
|
|
|
|
|
|
|
|
if len(dbType) > 0 {
|
|
|
|
return x.DumpTablesToFile(tbs, filePath, schemas.DBType(dbType))
|
|
|
|
}
|
|
|
|
return x.DumpTablesToFile(tbs, filePath)
|
|
|
|
}
|
|
|
|
|
|
|
|
// MaxBatchInsertSize returns the table's max batch insert size
|
|
|
|
func MaxBatchInsertSize(bean interface{}) int {
|
|
|
|
t, err := x.TableInfo(bean)
|
|
|
|
if err != nil {
|
|
|
|
return 50
|
|
|
|
}
|
|
|
|
return 999 / len(t.ColumnsSeq())
|
|
|
|
}
|
|
|
|
|
|
|
|
// Count returns records number according struct's fields as database query conditions
|
|
|
|
func Count(bean interface{}) (int64, error) {
|
|
|
|
return x.Count(bean)
|
|
|
|
}
|
|
|
|
|
|
|
|
// IsTableNotEmpty returns true if table has at least one record
|
|
|
|
func IsTableNotEmpty(tableName string) (bool, error) {
|
|
|
|
return x.Table(tableName).Exist()
|
|
|
|
}
|
|
|
|
|
|
|
|
// DeleteAllRecords will delete all the records of this table
|
|
|
|
func DeleteAllRecords(tableName string) error {
|
|
|
|
_, err := x.Exec(fmt.Sprintf("DELETE FROM %s", tableName))
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
// GetMaxID will return max id of the table
|
|
|
|
func GetMaxID(beanOrTableName interface{}) (maxID int64, err error) {
|
|
|
|
_, err = x.Select("MAX(id)").Table(beanOrTableName).Get(&maxID)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
// FindByMaxID filled results as the condition from database
|
|
|
|
func FindByMaxID(maxID int64, limit int, results interface{}) error {
|
|
|
|
return x.Where("id <= ?", maxID).
|
|
|
|
OrderBy("id DESC").
|
|
|
|
Limit(limit).
|
|
|
|
Find(results)
|
|
|
|
}
|