code.gitea.io/gitea@v1.22.3/models/repo/update.go (about)

     1  // Copyright 2021 The Gitea Authors. All rights reserved.
     2  // SPDX-License-Identifier: MIT
     3  
     4  package repo
     5  
     6  import (
     7  	"context"
     8  	"fmt"
     9  	"time"
    10  
    11  	"code.gitea.io/gitea/models/db"
    12  	user_model "code.gitea.io/gitea/models/user"
    13  	"code.gitea.io/gitea/modules/log"
    14  	"code.gitea.io/gitea/modules/util"
    15  )
    16  
    17  // UpdateRepositoryOwnerNames updates repository owner_names (this should only be used when the ownerName has changed case)
    18  func UpdateRepositoryOwnerNames(ctx context.Context, ownerID int64, ownerName string) error {
    19  	if ownerID == 0 {
    20  		return nil
    21  	}
    22  	ctx, committer, err := db.TxContext(ctx)
    23  	if err != nil {
    24  		return err
    25  	}
    26  	defer committer.Close()
    27  
    28  	if _, err := db.GetEngine(ctx).Where("owner_id = ?", ownerID).Cols("owner_name").Update(&Repository{
    29  		OwnerName: ownerName,
    30  	}); err != nil {
    31  		return err
    32  	}
    33  
    34  	return committer.Commit()
    35  }
    36  
    37  // UpdateRepositoryUpdatedTime updates a repository's updated time
    38  func UpdateRepositoryUpdatedTime(ctx context.Context, repoID int64, updateTime time.Time) error {
    39  	_, err := db.GetEngine(ctx).Exec("UPDATE repository SET updated_unix = ? WHERE id = ?", updateTime.Unix(), repoID)
    40  	return err
    41  }
    42  
    43  // UpdateRepositoryCols updates repository's columns
    44  func UpdateRepositoryCols(ctx context.Context, repo *Repository, cols ...string) error {
    45  	_, err := db.GetEngine(ctx).ID(repo.ID).Cols(cols...).Update(repo)
    46  	return err
    47  }
    48  
    49  // ErrReachLimitOfRepo represents a "ReachLimitOfRepo" kind of error.
    50  type ErrReachLimitOfRepo struct {
    51  	Limit int
    52  }
    53  
    54  // IsErrReachLimitOfRepo checks if an error is a ErrReachLimitOfRepo.
    55  func IsErrReachLimitOfRepo(err error) bool {
    56  	_, ok := err.(ErrReachLimitOfRepo)
    57  	return ok
    58  }
    59  
    60  func (err ErrReachLimitOfRepo) Error() string {
    61  	return fmt.Sprintf("user has reached maximum limit of repositories [limit: %d]", err.Limit)
    62  }
    63  
    64  func (err ErrReachLimitOfRepo) Unwrap() error {
    65  	return util.ErrPermissionDenied
    66  }
    67  
    68  // ErrRepoAlreadyExist represents a "RepoAlreadyExist" kind of error.
    69  type ErrRepoAlreadyExist struct {
    70  	Uname string
    71  	Name  string
    72  }
    73  
    74  // IsErrRepoAlreadyExist checks if an error is a ErrRepoAlreadyExist.
    75  func IsErrRepoAlreadyExist(err error) bool {
    76  	_, ok := err.(ErrRepoAlreadyExist)
    77  	return ok
    78  }
    79  
    80  func (err ErrRepoAlreadyExist) Error() string {
    81  	return fmt.Sprintf("repository already exists [uname: %s, name: %s]", err.Uname, err.Name)
    82  }
    83  
    84  func (err ErrRepoAlreadyExist) Unwrap() error {
    85  	return util.ErrAlreadyExist
    86  }
    87  
    88  // ErrRepoFilesAlreadyExist represents a "RepoFilesAlreadyExist" kind of error.
    89  type ErrRepoFilesAlreadyExist struct {
    90  	Uname string
    91  	Name  string
    92  }
    93  
    94  // IsErrRepoFilesAlreadyExist checks if an error is a ErrRepoAlreadyExist.
    95  func IsErrRepoFilesAlreadyExist(err error) bool {
    96  	_, ok := err.(ErrRepoFilesAlreadyExist)
    97  	return ok
    98  }
    99  
   100  func (err ErrRepoFilesAlreadyExist) Error() string {
   101  	return fmt.Sprintf("repository files already exist [uname: %s, name: %s]", err.Uname, err.Name)
   102  }
   103  
   104  func (err ErrRepoFilesAlreadyExist) Unwrap() error {
   105  	return util.ErrAlreadyExist
   106  }
   107  
   108  // CheckCreateRepository check if could created a repository
   109  func CheckCreateRepository(ctx context.Context, doer, u *user_model.User, name string, overwriteOrAdopt bool) error {
   110  	if !doer.CanCreateRepo() {
   111  		return ErrReachLimitOfRepo{u.MaxRepoCreation}
   112  	}
   113  
   114  	if err := IsUsableRepoName(name); err != nil {
   115  		return err
   116  	}
   117  
   118  	has, err := IsRepositoryModelOrDirExist(ctx, u, name)
   119  	if err != nil {
   120  		return fmt.Errorf("IsRepositoryExist: %w", err)
   121  	} else if has {
   122  		return ErrRepoAlreadyExist{u.Name, name}
   123  	}
   124  
   125  	repoPath := RepoPath(u.Name, name)
   126  	isExist, err := util.IsExist(repoPath)
   127  	if err != nil {
   128  		log.Error("Unable to check if %s exists. Error: %v", repoPath, err)
   129  		return err
   130  	}
   131  	if !overwriteOrAdopt && isExist {
   132  		return ErrRepoFilesAlreadyExist{u.Name, name}
   133  	}
   134  	return nil
   135  }
   136  
   137  // UpdateRepoSize updates the repository size, calculating it using getDirectorySize
   138  func UpdateRepoSize(ctx context.Context, repoID, gitSize, lfsSize int64) error {
   139  	_, err := db.GetEngine(ctx).ID(repoID).Cols("size", "git_size", "lfs_size").NoAutoTime().Update(&Repository{
   140  		Size:    gitSize + lfsSize,
   141  		GitSize: gitSize,
   142  		LFSSize: lfsSize,
   143  	})
   144  	return err
   145  }