// https://github.com/gogits/go-gogs-client/wiki/Administration-Users#create-a-new-user func CreateUser(ctx *middleware.Context, form api.CreateUserOption) { u := &models.User{ Name: form.Username, Email: form.Email, Passwd: form.Password, IsActive: true, LoginType: models.LOGIN_PLAIN, } parseLoginSource(ctx, u, form.SourceID, form.LoginName) if ctx.Written() { return } if err := models.CreateUser(u); err != nil { if models.IsErrUserAlreadyExist(err) || models.IsErrEmailAlreadyUsed(err) || models.IsErrNameReserved(err) || models.IsErrNamePatternNotAllowed(err) { ctx.APIError(422, "", err) } else { ctx.APIError(500, "CreateUser", err) } return } log.Trace("Account created by admin (%s): %s", ctx.User.Name, u.Name) // Send e-mail notification. if form.SendNotify && setting.MailService != nil { mailer.SendRegisterNotifyMail(ctx.Context, u) } ctx.JSON(201, convert.ToApiUser(u)) }
// https://github.com/gogits/go-gogs-client/wiki/Administration-Organizations#create-a-new-organization func CreateOrg(ctx *middleware.Context, form api.CreateOrgOption) { u := user.GetUserByParams(ctx) if ctx.Written() { return } org := &models.User{ Name: form.UserName, FullName: form.FullName, Description: form.Description, Website: form.Website, Location: form.Location, IsActive: true, Type: models.ORGANIZATION, } if err := models.CreateOrganization(org, u); err != nil { if models.IsErrUserAlreadyExist(err) || models.IsErrNameReserved(err) || models.IsErrNamePatternNotAllowed(err) { ctx.APIError(422, "CreateOrganization", err) } else { ctx.APIError(500, "CreateOrganization", err) } return } ctx.JSON(201, convert.ToApiOrganization(org)) }
func AddCollaborator(ctx *middleware.Context, opt api.CollaboratorOption) { u, err := models.GetUserByName(opt.UserName) if err != nil { if models.IsErrUserNotExist(err) { ctx.APIError(422, "", err) } else { ctx.Handle(500, "GetUserByName", err) } return } // Check if user is organization member. if ctx.Repo.Owner.IsOrganization() && ctx.Repo.Owner.IsOrgMember(u.Id) { ctx.APIError(422, "", "User is organization member") return } if err = ctx.Repo.Repository.AddCollaborator(u); err != nil { ctx.Handle(500, "AddCollaborator", err) return } if setting.Service.EnableNotifyMail { if err = mailer.SendCollaboratorMail(ctx.Render, u, ctx.User, ctx.Repo.Repository); err != nil { ctx.Handle(500, "SendCollaboratorMail", err) return } } ctx.Status(201) }
func HandleCheckKeyStringError(ctx *middleware.Context, err error) { if models.IsErrKeyUnableVerify(err) { ctx.APIError(422, "", "Unable to verify key content") } else { ctx.APIError(422, "", fmt.Errorf("Invalid key content: %v", err)) } }
func DeleteRepo(ctx *middleware.Context) { user, err := models.GetUserByName(ctx.Params(":username")) if err != nil { if models.IsErrUserNotExist(err) { ctx.APIError(422, "", err) } else { ctx.APIError(500, "GetUserByName", err) } return } repo, err := models.GetRepositoryByName(user.Id, ctx.Params(":reponame")) if err != nil { if models.IsErrRepoNotExist(err) { ctx.Error(404) } else { ctx.APIError(500, "GetRepositoryByName", err) } return } if user.IsOrganization() && !user.IsOwnedBy(ctx.User.Id) { ctx.APIError(403, "", "Given user is not owner of organization.") return } if err := models.DeleteRepository(user.Id, repo.ID); err != nil { ctx.APIError(500, "DeleteRepository", err) return } log.Trace("Repository deleted: %s/%s", user.Name, repo.Name) ctx.Status(204) }
// https://github.com/gogits/go-gogs-client/wiki/Users-Emails#add-email-addresses func AddEmail(ctx *middleware.Context, form api.CreateEmailOption) { if len(form.Emails) == 0 { ctx.Status(422) return } emails := make([]*models.EmailAddress, len(form.Emails)) for i := range form.Emails { emails[i] = &models.EmailAddress{ UID: ctx.User.Id, Email: form.Emails[i], IsActivated: !setting.Service.RegisterEmailConfirm, } } if err := models.AddEmailAddresses(emails); err != nil { if models.IsErrEmailAlreadyUsed(err) { ctx.APIError(422, "", "Email address has been used: "+err.(models.ErrEmailAlreadyUsed).Email) } else { ctx.APIError(500, "AddEmailAddresses", err) } return } apiEmails := make([]*api.Email, len(emails)) for i := range emails { apiEmails[i] = convert.ToApiEmail(emails[i]) } ctx.JSON(201, &apiEmails) }
// https://github.com/gogits/go-gogs-client/wiki/Repositories---Deploy-Keys#add-a-new-deploy-key func CreateRepoDeployKey(ctx *middleware.Context, form api.CreateKeyOption) { content, err := models.CheckPublicKeyString(form.Key) if err != nil { if models.IsErrKeyUnableVerify(err) { ctx.APIError(422, "", "Unable to verify key content") } else { ctx.APIError(422, "", fmt.Errorf("Invalid key content: %v", err)) } return } key, err := models.AddDeployKey(ctx.Repo.Repository.ID, form.Title, content) if err != nil { ctx.Data["HasError"] = true switch { case models.IsErrKeyAlreadyExist(err): ctx.APIError(422, "", "Key content has been used as non-deploy key") case models.IsErrKeyNameAlreadyUsed(err): ctx.APIError(422, "", "Key title has been used") default: ctx.APIError(500, "AddDeployKey", err) } return } key.Content = content apiLink := composeDeployKeysAPILink(ctx.Repo.Owner.Name + "/" + ctx.Repo.Repository.Name) ctx.JSON(201, ToApiDeployKey(apiLink, key)) }
func createRepo(ctx *middleware.Context, owner *models.User, opt api.CreateRepoOption) { repo, err := models.CreateRepository(owner, models.CreateRepoOptions{ Name: opt.Name, Description: opt.Description, Gitignores: opt.Gitignores, License: opt.License, Readme: opt.Readme, IsPrivate: opt.Private, AutoInit: opt.AutoInit, }) if err != nil { if models.IsErrRepoAlreadyExist(err) || models.IsErrNameReserved(err) || models.IsErrNamePatternNotAllowed(err) { ctx.APIError(422, "", err) } else { if repo != nil { if err = models.DeleteRepository(ctx.User.Id, repo.ID); err != nil { log.Error(4, "DeleteRepository: %v", err) } } ctx.APIError(500, "CreateRepository", err) } return } ctx.JSON(201, ToApiRepository(owner, repo, api.Permission{true, true, true})) }
// https://github.com/kiliit/go-gogs-client/wiki/Repositories#list-your-repositories func ListMyRepos(ctx *middleware.Context) { ownRepos, err := models.GetRepositories(ctx.User.Id, true) if err != nil { ctx.APIError(500, "GetRepositories", err) return } numOwnRepos := len(ownRepos) accessibleRepos, err := ctx.User.GetRepositoryAccesses() if err != nil { ctx.APIError(500, "GetRepositoryAccesses", err) return } repos := make([]*api.Repository, numOwnRepos+len(accessibleRepos)) for i := range ownRepos { repos[i] = ToApiRepository(ctx.User, ownRepos[i], api.Permission{true, true, true}) } i := numOwnRepos for repo, access := range accessibleRepos { repos[i] = ToApiRepository(repo.Owner, repo, api.Permission{ Admin: access >= models.ACCESS_MODE_ADMIN, Push: access >= models.ACCESS_MODE_WRITE, Pull: true, }) i++ } ctx.JSON(200, &repos) }
// https://github.com/kiliit/go-gogs-client/wiki/Repositories#create func CreateRepo(ctx *middleware.Context, opt api.CreateRepoOption) { // Shouldn't reach this condition, but just in case. if ctx.User.IsOrganization() { ctx.APIError(422, "", "not allowed creating repository for organization") return } createRepo(ctx, ctx.User, opt) }
// Render a Markdown document in raw mode. func MarkdownRaw(ctx *middleware.Context) { body, err := ctx.Req.Body().Bytes() if err != nil { ctx.APIError(422, "", err) return } ctx.Write(base.RenderRawMarkdown(body, "")) }
func listUserFollowing(ctx *middleware.Context, u *models.User) { users, err := u.GetFollowing(ctx.QueryInt("page")) if err != nil { ctx.APIError(500, "GetFollowing", err) return } responseApiUsers(ctx, users) }
// https://github.com/gogits/go-gogs-client/wiki/Repositories---Deploy-Keys#remove-a-deploy-key func DeleteRepoDeploykey(ctx *middleware.Context) { if err := models.DeleteDeployKey(ctx.ParamsInt64(":id")); err != nil { ctx.APIError(500, "DeleteDeployKey", err) return } ctx.Status(204) }
func CommitByID(ctx *middleware.Context) { commit, err := ctx.Repo.GitRepo.GetCommit(ctx.Params(":commitid")) if err != nil { log.Error(4, "GetCommit: %v", err) ctx.APIError(500, "GetCommit", err.Error()) return } ctx.JSON(200, ToApiCommit(commit)) }
// https://github.com/gogits/go-gogs-client/wiki/Repositories-Contents#download-archive func GetRepoArchive(ctx *middleware.Context) { repoPath := models.RepoPath(ctx.Params(":username"), ctx.Params(":reponame")) gitRepo, err := git.OpenRepository(repoPath) if err != nil { ctx.APIError(500, "OpenRepository", err) return } ctx.Repo.GitRepo = gitRepo repo.Download(ctx) }
// https://github.com/gogits/go-gogs-client/wiki/Users-Followers#follow-a-user func Follow(ctx *middleware.Context) { target := GetUserByParams(ctx) if ctx.Written() { return } if err := models.FollowUser(ctx.User.Id, target.Id); err != nil { ctx.APIError(500, "FollowUser", err) return } ctx.Status(204) }
// POST /users/:username/tokens func CreateAccessToken(ctx *middleware.Context, form CreateAccessTokenForm) { t := &models.AccessToken{ UID: ctx.User.Id, Name: form.Name, } if err := models.NewAccessToken(t); err != nil { ctx.APIError(500, "NewAccessToken", err) return } ctx.JSON(201, &api.AccessToken{t.Name, t.Sha1}) }
func listUserOrgs(ctx *middleware.Context, u *models.User, all bool) { if err := u.GetOrganizations(all); err != nil { ctx.APIError(500, "GetOrganizations", err) return } apiOrgs := make([]*api.Organization, len(u.Orgs)) for i := range u.Orgs { apiOrgs[i] = convert.ToApiOrganization(u.Orgs[i]) } ctx.JSON(200, &apiOrgs) }
func GetUserByParamsName(ctx *middleware.Context, name string) *models.User { user, err := models.GetUserByName(ctx.Params(name)) if err != nil { if models.IsErrUserNotExist(err) { ctx.Error(404) } else { ctx.APIError(500, "GetUserByName", err) } return nil } return user }
// https://github.com/gogits/go-gogs-client/wiki/Users-Public-Keys#delete-a-public-key func DeleteUserPublicKey(ctx *middleware.Context) { if err := models.DeletePublicKey(ctx.User, ctx.ParamsInt64(":id")); err != nil { if models.IsErrKeyAccessDenied(err) { ctx.APIError(403, "", "You do not have access to this key") } else { ctx.APIError(500, "DeletePublicKey", err) } return } ctx.Status(204) }
// https://github.com/gogits/go-gogs-client/wiki/Users-Public-Keys#list-public-keys-for-a-user func ListUserPublicKeys(ctx *middleware.Context) { user, err := models.GetUserByName(ctx.Params(":username")) if err != nil { if models.IsErrUserNotExist(err) { ctx.Error(404) } else { ctx.APIError(500, "GetUserByName", err) } return } listUserPublicKeys(ctx, user.Id) }
// GET /users/:username/tokens func ListAccessTokens(ctx *middleware.Context) { tokens, err := models.ListAccessTokens(ctx.User.Id) if err != nil { ctx.APIError(500, "ListAccessTokens", err) return } apiTokens := make([]*api.AccessToken, len(tokens)) for i := range tokens { apiTokens[i] = &api.AccessToken{tokens[i].Name, tokens[i].Sha1} } ctx.JSON(200, &apiTokens) }
// https://github.com/gogits/go-gogs-client/wiki/Repositories#list-hooks func ListHooks(ctx *middleware.Context) { hooks, err := models.GetWebhooksByRepoID(ctx.Repo.Repository.ID) if err != nil { ctx.APIError(500, "GetWebhooksByRepoID", err) return } apiHooks := make([]*api.Hook, len(hooks)) for i := range hooks { apiHooks[i] = convert.ToApiHook(ctx.Repo.RepoLink, hooks[i]) } ctx.JSON(200, &apiHooks) }
func listUserPublicKeys(ctx *middleware.Context, uid int64) { keys, err := models.ListPublicKeys(uid) if err != nil { ctx.APIError(500, "ListPublicKeys", err) return } apiLink := composePublicKeysAPILink() apiKeys := make([]*api.PublicKey, len(keys)) for i := range keys { apiKeys[i] = ToApiPublicKey(apiLink, keys[i]) } ctx.JSON(200, &apiKeys) }
// https://github.com/gogits/go-gogs-client/wiki/Repositories#get-branch func GetBranch(ctx *middleware.Context) { branch, err := ctx.Repo.Repository.GetBranch(ctx.Params(":branchname")) if err != nil { ctx.APIError(500, "GetBranch", err) return } c, err := branch.GetCommit() if err != nil { ctx.APIError(500, "GetCommit", err) return } ctx.JSON(200, convert.ToApiBranch(branch, c)) }
// https://github.com/gogits/go-gogs-client/wiki/Administration-Users#edit-an-existing-user func EditUser(ctx *middleware.Context, form api.EditUserOption) { u := user.GetUserByParams(ctx) if ctx.Written() { return } parseLoginSource(ctx, u, form.SourceID, form.LoginName) if ctx.Written() { return } if len(form.Password) > 0 { u.Passwd = form.Password u.Salt = models.GetUserSalt() u.EncodePasswd() } u.LoginName = form.LoginName u.FullName = form.FullName u.Email = form.Email u.Website = form.Website u.Location = form.Location if form.Active != nil { u.IsActive = *form.Active } if form.Admin != nil { u.IsAdmin = *form.Admin } if form.AllowGitHook != nil { u.AllowGitHook = *form.AllowGitHook } if form.AllowImportLocal != nil { u.AllowImportLocal = *form.AllowImportLocal } if err := models.UpdateUser(u); err != nil { if models.IsErrEmailAlreadyUsed(err) { ctx.APIError(422, "", err) } else { ctx.APIError(500, "UpdateUser", err) } return } log.Trace("Account profile updated by admin (%s): %s", ctx.User.Name, u.Name) ctx.JSON(200, convert.ToApiUser(u)) }
// GET /users/:username func GetUserInfo(ctx *middleware.Context) { u, err := models.GetUserByName(ctx.Params(":username")) if err != nil { if models.IsErrUserNotExist(err) { ctx.Error(404) } else { ctx.APIError(500, "GetUserByName", err) } return } // Hide user e-mail when API caller isn't signed in. if !ctx.IsSigned { u.Email = "" } ctx.JSON(200, &api.User{u.Id, u.Name, u.FullName, u.Email, u.AvatarLink()}) }
func ListCommits(ctx *middleware.Context) { commits, err := ctx.Repo.Commit.CommitsBefore() if err != nil { log.Error(4, "CommitsBefore: %v", err) ctx.APIError(500, "CommitsBefore", err) return } apiCommits := make([]*api.Commit, commits.Len()) i := 0 for e := commits.Front(); e != nil; e = e.Next() { apiCommits[i] = ToApiCommit(e.Value.(*git.Commit)) i = i + 1 } ctx.JSON(200, apiCommits) }
// https://github.com/gogits/go-gogs-client/wiki/Miscellaneous#render-an-arbitrary-markdown-document func Markdown(ctx *middleware.Context, form api.MarkdownOption) { if ctx.HasApiError() { ctx.APIError(422, "", ctx.GetErrMsg()) return } if len(form.Text) == 0 { ctx.Write([]byte("")) return } switch form.Mode { case "gfm": ctx.Write(markdown.Render([]byte(form.Text), form.Context, nil)) default: ctx.Write(markdown.RenderRaw([]byte(form.Text), "")) } }
// Render an arbitrary Markdown document. func Markdown(ctx *middleware.Context, form apiv1.MarkdownForm) { if ctx.HasApiError() { ctx.APIError(422, "", ctx.GetErrMsg()) return } if len(form.Text) == 0 { ctx.Write([]byte("")) return } switch form.Mode { case "gfm": ctx.Write(base.RenderMarkdown([]byte(form.Text), setting.AppUrl+strings.TrimPrefix(form.Context, "/"))) default: ctx.Write(base.RenderRawMarkdown([]byte(form.Text), "")) } }