pkg/bufman/controllers/repository.go - dubbo-kubernetes - Git at Google

 // Licensed to the Apache Software Foundation (ASF) under one or more
 // contributor license agreements.  See the NOTICE file distributed with
 // this work for additional information regarding copyright ownership.
 // The ASF licenses this file to You under the Apache License, Version 2.0
 // (the "License"); you may not use this file except in compliance with
 // the License.  You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package controllers

 import (
 	"context"
 )

 import (
 	"github.com/apache/dubbo-kubernetes/pkg/bufman/constant"
 	"github.com/apache/dubbo-kubernetes/pkg/bufman/core/security"
 	"github.com/apache/dubbo-kubernetes/pkg/bufman/core/validity"
 	"github.com/apache/dubbo-kubernetes/pkg/bufman/e"
 	registryv1alpha1 "github.com/apache/dubbo-kubernetes/pkg/bufman/gen/proto/go/registry/v1alpha1"
 	"github.com/apache/dubbo-kubernetes/pkg/bufman/services"
 	"github.com/apache/dubbo-kubernetes/pkg/core/logger"
 )

 type RepositoryController struct {
 	repositoryService    services.RepositoryService
 	authorizationService services.AuthorizationService
 	validator            validity.Validator
 }

 func NewRepositoryController() *RepositoryController {
 	return &RepositoryController{
 		repositoryService:    services.NewRepositoryService(),
 		authorizationService: services.NewAuthorizationService(),
 		validator:            validity.NewValidator(),
 	}
 }

 func (controller *RepositoryController) GetRepository(ctx context.Context, req *registryv1alpha1.GetRepositoryRequest) (*registryv1alpha1.GetRepositoryResponse, e.ResponseError) {
 	// 查询
 	repository, err := controller.repositoryService.GetRepository(ctx, req.GetId())
 	if err != nil {
 		logger.Sugar().Errorf("Error get repo: %v\n", err.Error())

 		return nil, err
 	}

 	repositoryCounts, err := controller.repositoryService.GetRepositoryCounts(ctx, repository.RepositoryID)
 	if err != nil {
 		logger.Sugar().Errorf("Error get repo counts: %v\n", err.Error())

 		return nil, err
 	}

 	// 查询成功
 	resp := &registryv1alpha1.GetRepositoryResponse{
 		Repository: repository.ToProtoRepository(),
 		Counts:     repositoryCounts.ToProtoRepositoryCounts(),
 	}
 	return resp, nil
 }

 func (controller *RepositoryController) GetRepositoryByFullName(ctx context.Context, req *registryv1alpha1.GetRepositoryByFullNameRequest) (*registryv1alpha1.GetRepositoryByFullNameResponse, e.ResponseError) {
 	// 验证参数
 	userName, repositoryName, argErr := controller.validator.SplitFullName(req.GetFullName())
 	if argErr != nil {
 		logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

 		return nil, argErr
 	}

 	// 查询
 	repository, err := controller.repositoryService.GetRepositoryByUserNameAndRepositoryName(ctx, userName, repositoryName)
 	if err != nil {
 		logger.Sugar().Errorf("Error get repo: %v\n", err.Error())

 		return nil, err
 	}

 	repositoryCounts, err := controller.repositoryService.GetRepositoryCounts(ctx, repository.RepositoryID)
 	if err != nil {
 		logger.Sugar().Errorf("Error get repo counts: %v\n", err.Error())

 		return nil, err
 	}

 	// 查询成功
 	resp := &registryv1alpha1.GetRepositoryByFullNameResponse{
 		Repository: repository.ToProtoRepository(),
 		Counts:     repositoryCounts.ToProtoRepositoryCounts(),
 	}
 	return resp, nil
 }

 func (controller *RepositoryController) ListRepositories(ctx context.Context, req *registryv1alpha1.ListRepositoriesRequest) (*registryv1alpha1.ListRepositoriesResponse, e.ResponseError) {
 	// 验证参数
 	argErr := controller.validator.CheckPageSize(req.GetPageSize())
 	if argErr != nil {
 		logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

 		return nil, argErr
 	}

 	// 解析page token
 	pageTokenChaim, err := security.ParsePageToken(req.GetPageToken())
 	if err != nil {
 		logger.Sugar().Errorf("Error parse page token: %v\n", err.Error())

 		respErr := e.NewInvalidArgumentError(err)
 		return nil, respErr
 	}

 	repositories, listErr := controller.repositoryService.ListRepositories(ctx, pageTokenChaim.PageOffset, int(req.GetPageSize()), req.Reverse)
 	if listErr != nil {
 		logger.Sugar().Errorf("Error list repos: %v\n", listErr.Error())

 		return nil, listErr
 	}

 	// 生成下一页token
 	nextPageToken, err := security.GenerateNextPageToken(pageTokenChaim.PageOffset, int(req.GetPageSize()), len(repositories))
 	if err != nil {
 		logger.Sugar().Errorf("Error generate next page token: %v\n", err.Error())

 		respErr := e.NewInternalError(err)
 		return nil, respErr
 	}

 	resp := &registryv1alpha1.ListRepositoriesResponse{
 		Repositories:  repositories.ToProtoRepositories(),
 		NextPageToken: nextPageToken,
 	}
 	return resp, nil
 }

 func (controller *RepositoryController) ListUserRepositories(ctx context.Context, req *registryv1alpha1.ListUserRepositoriesRequest) (*registryv1alpha1.ListUserRepositoriesResponse, e.ResponseError) {
 	// 验证参数
 	argErr := controller.validator.CheckPageSize(req.GetPageSize())
 	if argErr != nil {
 		logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

 		return nil, argErr
 	}

 	// 解析page token
 	pageTokenChaim, err := security.ParsePageToken(req.GetPageToken())
 	if err != nil {
 		logger.Sugar().Errorf("Error parse page token: %v\n", err.Error())

 		respErr := e.NewInvalidArgumentError(err)
 		return nil, respErr
 	}

 	repositories, listErr := controller.repositoryService.ListUserRepositories(ctx, req.GetUserId(), pageTokenChaim.PageOffset, int(req.GetPageSize()), req.GetReverse())
 	if err != nil {
 		logger.Sugar().Errorf("Error list user repos: %v\n", listErr.Error())

 		return nil, listErr
 	}

 	// 生成下一页token
 	nextPageToken, err := security.GenerateNextPageToken(pageTokenChaim.PageOffset, int(req.GetPageSize()), len(repositories))
 	if err != nil {
 		logger.Sugar().Errorf("Error generate next page token: %v\n", err.Error())

 		respErr := e.NewInternalError(err)
 		return nil, respErr
 	}

 	resp := &registryv1alpha1.ListUserRepositoriesResponse{
 		Repositories:  repositories.ToProtoRepositories(),
 		NextPageToken: nextPageToken,
 	}
 	return resp, nil
 }

 func (controller *RepositoryController) ListRepositoriesUserCanAccess(ctx context.Context, req *registryv1alpha1.ListRepositoriesUserCanAccessRequest) (*registryv1alpha1.ListRepositoriesUserCanAccessResponse, e.ResponseError) {
 	// 验证参数
 	argErr := controller.validator.CheckPageSize(req.GetPageSize())
 	if argErr != nil {
 		logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

 		return nil, argErr
 	}

 	// 解析page token
 	pageTokenChaim, err := security.ParsePageToken(req.GetPageToken())
 	if err != nil {
 		logger.Sugar().Errorf("Error parse page token: %v\n", err.Error())

 		respErr := e.NewInvalidArgumentError(err)
 		return nil, respErr
 	}

 	userID, _ := ctx.Value(constant.UserIDKey).(string)
 	repositories, ListErr := controller.repositoryService.ListRepositoriesUserCanAccess(ctx, userID, pageTokenChaim.PageOffset, int(req.GetPageSize()), req.GetReverse())
 	if err != nil {
 		logger.Sugar().Errorf("Error list repos user can access: %v\n", ListErr.Error())

 		return nil, ListErr
 	}

 	// 生成下一页token
 	nextPageToken, err := security.GenerateNextPageToken(pageTokenChaim.PageOffset, int(req.GetPageSize()), len(repositories))
 	if err != nil {
 		logger.Sugar().Errorf("Error generate next page token: %v\n", err.Error())

 		respErr := e.NewInternalError(err)
 		return nil, respErr
 	}

 	resp := &registryv1alpha1.ListRepositoriesUserCanAccessResponse{
 		Repositories:  repositories.ToProtoRepositories(),
 		NextPageToken: nextPageToken,
 	}
 	return resp, nil
 }

 func (controller *RepositoryController) CreateRepositoryByFullName(ctx context.Context, req *registryv1alpha1.CreateRepositoryByFullNameRequest) (*registryv1alpha1.CreateRepositoryByFullNameResponse, e.ResponseError) {
 	// 验证参数
 	userName, repositoryName, argErr := controller.validator.SplitFullName(req.GetFullName())
 	if argErr != nil {
 		logger.Sugar().Errorf("Error check: %v", argErr.Error())

 		return nil, argErr
 	}
 	argErr = controller.validator.CheckRepositoryName(repositoryName)
 	if argErr != nil {
 		logger.Sugar().Errorf("Error check: %v", argErr.Error())

 		return nil, argErr
 	}

 	userID, _ := ctx.Value(constant.UserIDKey).(string)

 	// 创建
 	repository, err := controller.repositoryService.CreateRepositoryByUserNameAndRepositoryName(ctx, userID, userName, repositoryName, req.GetVisibility())
 	if err != nil {
 		logger.Sugar().Errorf("Error create repo: %v", err.Error())

 		return nil, err
 	}

 	// 成功
 	resp := &registryv1alpha1.CreateRepositoryByFullNameResponse{
 		Repository: repository.ToProtoRepository(),
 	}
 	return resp, nil
 }

 func (controller *RepositoryController) DeleteRepository(ctx context.Context, req *registryv1alpha1.DeleteRepositoryRequest) (*registryv1alpha1.DeleteRepositoryResponse, e.ResponseError) {
 	userID, _ := ctx.Value(constant.UserIDKey).(string)

 	// 验证用户权限
 	_, permissionErr := controller.authorizationService.CheckRepositoryCanDeleteByID(userID, req.GetId())
 	if permissionErr != nil {
 		logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

 		return nil, permissionErr
 	}

 	// 查询repository，检查是否可以删除
 	err := controller.repositoryService.DeleteRepository(ctx, req.GetId())
 	if err != nil {
 		logger.Sugar().Errorf("Error delete repo: %v", err.Error())

 		return nil, err
 	}

 	resp := &registryv1alpha1.DeleteRepositoryResponse{}
 	return resp, nil
 }

 func (controller *RepositoryController) DeleteRepositoryByFullName(ctx context.Context, req *registryv1alpha1.DeleteRepositoryByFullNameRequest) (*registryv1alpha1.DeleteRepositoryByFullNameResponse, e.ResponseError) {
 	// 验证参数
 	userName, repositoryName, argErr := controller.validator.SplitFullName(req.GetFullName())
 	if argErr != nil {
 		logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

 		return nil, argErr
 	}

 	userID, _ := ctx.Value(constant.UserIDKey).(string)

 	// 验证用户权限
 	_, permissionErr := controller.authorizationService.CheckRepositoryCanDelete(userID, userName, repositoryName)
 	if permissionErr != nil {
 		logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

 		return nil, permissionErr
 	}

 	// 删除
 	err := controller.repositoryService.DeleteRepositoryByUserNameAndRepositoryName(ctx, userName, repositoryName)
 	if err != nil {
 		logger.Sugar().Errorf("Error delete repo: %v", err.Error())

 		return nil, err
 	}

 	resp := &registryv1alpha1.DeleteRepositoryByFullNameResponse{}
 	return resp, nil
 }

 func (controller *RepositoryController) DeprecateRepositoryByName(ctx context.Context, req *registryv1alpha1.DeprecateRepositoryByNameRequest) (*registryv1alpha1.DeprecateRepositoryByNameResponse, e.ResponseError) {
 	userID, _ := ctx.Value(constant.UserIDKey).(string)

 	// 验证用户权限
 	_, permissionErr := controller.authorizationService.CheckRepositoryCanEdit(userID, req.GetOwnerName(), req.GetRepositoryName())
 	if permissionErr != nil {
 		logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

 		return nil, permissionErr
 	}

 	// 修改数据库
 	updatedRepository, err := controller.repositoryService.DeprecateRepositoryByName(ctx, req.GetOwnerName(), req.GetRepositoryName(), req.GetDeprecationMessage())
 	if err != nil {
 		logger.Sugar().Errorf("Error deprecate repo: %v", err.Error())

 		return nil, err
 	}

 	resp := &registryv1alpha1.DeprecateRepositoryByNameResponse{
 		Repository: updatedRepository.ToProtoRepository(),
 	}
 	return resp, nil
 }

 func (controller *RepositoryController) UndeprecateRepositoryByName(ctx context.Context, req *registryv1alpha1.UndeprecateRepositoryByNameRequest) (*registryv1alpha1.UndeprecateRepositoryByNameResponse, e.ResponseError) {
 	userID, _ := ctx.Value(constant.UserIDKey).(string)

 	// 验证用户权限
 	_, permissionErr := controller.authorizationService.CheckRepositoryCanEdit(userID, req.GetOwnerName(), req.GetRepositoryName())
 	if permissionErr != nil {
 		logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

 		return nil, permissionErr
 	}

 	// 修改数据库
 	updatedRepository, err := controller.repositoryService.UndeprecateRepositoryByName(ctx, req.GetOwnerName(), req.GetRepositoryName())
 	if err != nil {
 		logger.Sugar().Errorf("Error undeprecate repo: %v", err.Error())

 		return nil, err
 	}

 	resp := &registryv1alpha1.UndeprecateRepositoryByNameResponse{
 		Repository: updatedRepository.ToProtoRepository(),
 	}
 	return resp, nil
 }

 func (controller *RepositoryController) UpdateRepositorySettingsByName(ctx context.Context, req *registryv1alpha1.UpdateRepositorySettingsByNameRequest) (*registryv1alpha1.UpdateRepositorySettingsByNameResponse, e.ResponseError) {
 	userID, _ := ctx.Value(constant.UserIDKey).(string)

 	// 验证用户权限
 	_, permissionErr := controller.authorizationService.CheckRepositoryCanEdit(userID, req.GetOwnerName(), req.GetRepositoryName())
 	if permissionErr != nil {
 		logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

 		return nil, permissionErr
 	}

 	// 修改数据库
 	err := controller.repositoryService.UpdateRepositorySettingsByName(ctx, req.GetOwnerName(), req.GetRepositoryName(), req.GetVisibility(), req.GetDescription())
 	if err != nil {
 		logger.Sugar().Errorf("Error update repo settings: %v", err.Error())

 		return nil, err
 	}

 	resp := &registryv1alpha1.UpdateRepositorySettingsByNameResponse{}
 	return resp, nil
 }

 func (controller *RepositoryController) GetRepositoriesByFullName(ctx context.Context, req *registryv1alpha1.GetRepositoriesByFullNameRequest) (*registryv1alpha1.GetRepositoriesByFullNameResponse, e.ResponseError) {
 	retRepos := make([]*registryv1alpha1.Repository, 0, len(req.FullNames))
 	for _, fullName := range req.GetFullNames() {
 		// 验证参数
 		userName, repositoryName, argErr := controller.validator.SplitFullName(fullName)
 		if argErr != nil {
 			logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

 			return nil, argErr
 		}

 		// 查询
 		repository, err := controller.repositoryService.GetRepositoryByUserNameAndRepositoryName(ctx, userName, repositoryName)
 		if err != nil {
 			logger.Sugar().Errorf("Error get repo: %v\n", err.Error())

 			return nil, err
 		}
 		retRepos = append(retRepos, repository.ToProtoRepository())
 	}

 	resp := &registryv1alpha1.GetRepositoriesByFullNameResponse{
 		Repositories: retRepos,
 	}

 	return resp, nil
 }
	// Licensed to the Apache Software Foundation (ASF) under one or more
	// contributor license agreements. See the NOTICE file distributed with
	// this work for additional information regarding copyright ownership.
	// The ASF licenses this file to You under the Apache License, Version 2.0
	// (the "License"); you may not use this file except in compliance with
	// the License. You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package controllers

	import (
	"context"
	)

	import (
	"github.com/apache/dubbo-kubernetes/pkg/bufman/constant"
	"github.com/apache/dubbo-kubernetes/pkg/bufman/core/security"
	"github.com/apache/dubbo-kubernetes/pkg/bufman/core/validity"
	"github.com/apache/dubbo-kubernetes/pkg/bufman/e"
	registryv1alpha1 "github.com/apache/dubbo-kubernetes/pkg/bufman/gen/proto/go/registry/v1alpha1"
	"github.com/apache/dubbo-kubernetes/pkg/bufman/services"
	"github.com/apache/dubbo-kubernetes/pkg/core/logger"
	)

	type RepositoryController struct {
	repositoryService services.RepositoryService
	authorizationService services.AuthorizationService
	validator validity.Validator
	}

	func NewRepositoryController() *RepositoryController {
	return &RepositoryController{
	repositoryService: services.NewRepositoryService(),
	authorizationService: services.NewAuthorizationService(),
	validator: validity.NewValidator(),
	}
	}

	func (controller RepositoryController) GetRepository(ctx context.Context, req registryv1alpha1.GetRepositoryRequest) (*registryv1alpha1.GetRepositoryResponse, e.ResponseError) {
	// 查询
	repository, err := controller.repositoryService.GetRepository(ctx, req.GetId())
	if err != nil {
	logger.Sugar().Errorf("Error get repo: %v\n", err.Error())

	return nil, err
	}

	repositoryCounts, err := controller.repositoryService.GetRepositoryCounts(ctx, repository.RepositoryID)
	if err != nil {
	logger.Sugar().Errorf("Error get repo counts: %v\n", err.Error())

	return nil, err
	}

	// 查询成功
	resp := &registryv1alpha1.GetRepositoryResponse{
	Repository: repository.ToProtoRepository(),
	Counts: repositoryCounts.ToProtoRepositoryCounts(),
	}
	return resp, nil
	}

	func (controller RepositoryController) GetRepositoryByFullName(ctx context.Context, req registryv1alpha1.GetRepositoryByFullNameRequest) (*registryv1alpha1.GetRepositoryByFullNameResponse, e.ResponseError) {
	// 验证参数
	userName, repositoryName, argErr := controller.validator.SplitFullName(req.GetFullName())
	if argErr != nil {
	logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

	return nil, argErr
	}

	// 查询
	repository, err := controller.repositoryService.GetRepositoryByUserNameAndRepositoryName(ctx, userName, repositoryName)
	if err != nil {
	logger.Sugar().Errorf("Error get repo: %v\n", err.Error())

	return nil, err
	}

	repositoryCounts, err := controller.repositoryService.GetRepositoryCounts(ctx, repository.RepositoryID)
	if err != nil {
	logger.Sugar().Errorf("Error get repo counts: %v\n", err.Error())

	return nil, err
	}

	// 查询成功
	resp := &registryv1alpha1.GetRepositoryByFullNameResponse{
	Repository: repository.ToProtoRepository(),
	Counts: repositoryCounts.ToProtoRepositoryCounts(),
	}
	return resp, nil
	}

	func (controller RepositoryController) ListRepositories(ctx context.Context, req registryv1alpha1.ListRepositoriesRequest) (*registryv1alpha1.ListRepositoriesResponse, e.ResponseError) {
	// 验证参数
	argErr := controller.validator.CheckPageSize(req.GetPageSize())
	if argErr != nil {
	logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

	return nil, argErr
	}

	// 解析page token
	pageTokenChaim, err := security.ParsePageToken(req.GetPageToken())
	if err != nil {
	logger.Sugar().Errorf("Error parse page token: %v\n", err.Error())

	respErr := e.NewInvalidArgumentError(err)
	return nil, respErr
	}

	repositories, listErr := controller.repositoryService.ListRepositories(ctx, pageTokenChaim.PageOffset, int(req.GetPageSize()), req.Reverse)
	if listErr != nil {
	logger.Sugar().Errorf("Error list repos: %v\n", listErr.Error())

	return nil, listErr
	}

	// 生成下一页token
	nextPageToken, err := security.GenerateNextPageToken(pageTokenChaim.PageOffset, int(req.GetPageSize()), len(repositories))
	if err != nil {
	logger.Sugar().Errorf("Error generate next page token: %v\n", err.Error())

	respErr := e.NewInternalError(err)
	return nil, respErr
	}

	resp := &registryv1alpha1.ListRepositoriesResponse{
	Repositories: repositories.ToProtoRepositories(),
	NextPageToken: nextPageToken,
	}
	return resp, nil
	}

	func (controller RepositoryController) ListUserRepositories(ctx context.Context, req registryv1alpha1.ListUserRepositoriesRequest) (*registryv1alpha1.ListUserRepositoriesResponse, e.ResponseError) {
	// 验证参数
	argErr := controller.validator.CheckPageSize(req.GetPageSize())
	if argErr != nil {
	logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

	return nil, argErr
	}

	// 解析page token
	pageTokenChaim, err := security.ParsePageToken(req.GetPageToken())
	if err != nil {
	logger.Sugar().Errorf("Error parse page token: %v\n", err.Error())

	respErr := e.NewInvalidArgumentError(err)
	return nil, respErr
	}

	repositories, listErr := controller.repositoryService.ListUserRepositories(ctx, req.GetUserId(), pageTokenChaim.PageOffset, int(req.GetPageSize()), req.GetReverse())
	if err != nil {
	logger.Sugar().Errorf("Error list user repos: %v\n", listErr.Error())

	return nil, listErr
	}

	// 生成下一页token
	nextPageToken, err := security.GenerateNextPageToken(pageTokenChaim.PageOffset, int(req.GetPageSize()), len(repositories))
	if err != nil {
	logger.Sugar().Errorf("Error generate next page token: %v\n", err.Error())

	respErr := e.NewInternalError(err)
	return nil, respErr
	}

	resp := &registryv1alpha1.ListUserRepositoriesResponse{
	Repositories: repositories.ToProtoRepositories(),
	NextPageToken: nextPageToken,
	}
	return resp, nil
	}

	func (controller RepositoryController) ListRepositoriesUserCanAccess(ctx context.Context, req registryv1alpha1.ListRepositoriesUserCanAccessRequest) (*registryv1alpha1.ListRepositoriesUserCanAccessResponse, e.ResponseError) {
	// 验证参数
	argErr := controller.validator.CheckPageSize(req.GetPageSize())
	if argErr != nil {
	logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

	return nil, argErr
	}

	// 解析page token
	pageTokenChaim, err := security.ParsePageToken(req.GetPageToken())
	if err != nil {
	logger.Sugar().Errorf("Error parse page token: %v\n", err.Error())

	respErr := e.NewInvalidArgumentError(err)
	return nil, respErr
	}

	userID, _ := ctx.Value(constant.UserIDKey).(string)
	repositories, ListErr := controller.repositoryService.ListRepositoriesUserCanAccess(ctx, userID, pageTokenChaim.PageOffset, int(req.GetPageSize()), req.GetReverse())
	if err != nil {
	logger.Sugar().Errorf("Error list repos user can access: %v\n", ListErr.Error())

	return nil, ListErr
	}

	// 生成下一页token
	nextPageToken, err := security.GenerateNextPageToken(pageTokenChaim.PageOffset, int(req.GetPageSize()), len(repositories))
	if err != nil {
	logger.Sugar().Errorf("Error generate next page token: %v\n", err.Error())

	respErr := e.NewInternalError(err)
	return nil, respErr
	}

	resp := &registryv1alpha1.ListRepositoriesUserCanAccessResponse{
	Repositories: repositories.ToProtoRepositories(),
	NextPageToken: nextPageToken,
	}
	return resp, nil
	}

	func (controller RepositoryController) CreateRepositoryByFullName(ctx context.Context, req registryv1alpha1.CreateRepositoryByFullNameRequest) (*registryv1alpha1.CreateRepositoryByFullNameResponse, e.ResponseError) {
	// 验证参数
	userName, repositoryName, argErr := controller.validator.SplitFullName(req.GetFullName())
	if argErr != nil {
	logger.Sugar().Errorf("Error check: %v", argErr.Error())

	return nil, argErr
	}
	argErr = controller.validator.CheckRepositoryName(repositoryName)
	if argErr != nil {
	logger.Sugar().Errorf("Error check: %v", argErr.Error())

	return nil, argErr
	}

	userID, _ := ctx.Value(constant.UserIDKey).(string)

	// 创建
	repository, err := controller.repositoryService.CreateRepositoryByUserNameAndRepositoryName(ctx, userID, userName, repositoryName, req.GetVisibility())
	if err != nil {
	logger.Sugar().Errorf("Error create repo: %v", err.Error())

	return nil, err
	}

	// 成功
	resp := &registryv1alpha1.CreateRepositoryByFullNameResponse{
	Repository: repository.ToProtoRepository(),
	}
	return resp, nil
	}

	func (controller RepositoryController) DeleteRepository(ctx context.Context, req registryv1alpha1.DeleteRepositoryRequest) (*registryv1alpha1.DeleteRepositoryResponse, e.ResponseError) {
	userID, _ := ctx.Value(constant.UserIDKey).(string)

	// 验证用户权限
	_, permissionErr := controller.authorizationService.CheckRepositoryCanDeleteByID(userID, req.GetId())
	if permissionErr != nil {
	logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

	return nil, permissionErr
	}

	// 查询repository，检查是否可以删除
	err := controller.repositoryService.DeleteRepository(ctx, req.GetId())
	if err != nil {
	logger.Sugar().Errorf("Error delete repo: %v", err.Error())

	return nil, err
	}

	resp := &registryv1alpha1.DeleteRepositoryResponse{}
	return resp, nil
	}

	func (controller RepositoryController) DeleteRepositoryByFullName(ctx context.Context, req registryv1alpha1.DeleteRepositoryByFullNameRequest) (*registryv1alpha1.DeleteRepositoryByFullNameResponse, e.ResponseError) {
	// 验证参数
	userName, repositoryName, argErr := controller.validator.SplitFullName(req.GetFullName())
	if argErr != nil {
	logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

	return nil, argErr
	}

	userID, _ := ctx.Value(constant.UserIDKey).(string)

	// 验证用户权限
	_, permissionErr := controller.authorizationService.CheckRepositoryCanDelete(userID, userName, repositoryName)
	if permissionErr != nil {
	logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

	return nil, permissionErr
	}

	// 删除
	err := controller.repositoryService.DeleteRepositoryByUserNameAndRepositoryName(ctx, userName, repositoryName)
	if err != nil {
	logger.Sugar().Errorf("Error delete repo: %v", err.Error())

	return nil, err
	}

	resp := &registryv1alpha1.DeleteRepositoryByFullNameResponse{}
	return resp, nil
	}

	func (controller RepositoryController) DeprecateRepositoryByName(ctx context.Context, req registryv1alpha1.DeprecateRepositoryByNameRequest) (*registryv1alpha1.DeprecateRepositoryByNameResponse, e.ResponseError) {
	userID, _ := ctx.Value(constant.UserIDKey).(string)

	// 验证用户权限
	_, permissionErr := controller.authorizationService.CheckRepositoryCanEdit(userID, req.GetOwnerName(), req.GetRepositoryName())
	if permissionErr != nil {
	logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

	return nil, permissionErr
	}

	// 修改数据库
	updatedRepository, err := controller.repositoryService.DeprecateRepositoryByName(ctx, req.GetOwnerName(), req.GetRepositoryName(), req.GetDeprecationMessage())
	if err != nil {
	logger.Sugar().Errorf("Error deprecate repo: %v", err.Error())

	return nil, err
	}

	resp := &registryv1alpha1.DeprecateRepositoryByNameResponse{
	Repository: updatedRepository.ToProtoRepository(),
	}
	return resp, nil
	}

	func (controller RepositoryController) UndeprecateRepositoryByName(ctx context.Context, req registryv1alpha1.UndeprecateRepositoryByNameRequest) (*registryv1alpha1.UndeprecateRepositoryByNameResponse, e.ResponseError) {
	userID, _ := ctx.Value(constant.UserIDKey).(string)

	// 验证用户权限
	_, permissionErr := controller.authorizationService.CheckRepositoryCanEdit(userID, req.GetOwnerName(), req.GetRepositoryName())
	if permissionErr != nil {
	logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

	return nil, permissionErr
	}

	// 修改数据库
	updatedRepository, err := controller.repositoryService.UndeprecateRepositoryByName(ctx, req.GetOwnerName(), req.GetRepositoryName())
	if err != nil {
	logger.Sugar().Errorf("Error undeprecate repo: %v", err.Error())

	return nil, err
	}

	resp := &registryv1alpha1.UndeprecateRepositoryByNameResponse{
	Repository: updatedRepository.ToProtoRepository(),
	}
	return resp, nil
	}

	func (controller RepositoryController) UpdateRepositorySettingsByName(ctx context.Context, req registryv1alpha1.UpdateRepositorySettingsByNameRequest) (*registryv1alpha1.UpdateRepositorySettingsByNameResponse, e.ResponseError) {
	userID, _ := ctx.Value(constant.UserIDKey).(string)

	// 验证用户权限
	_, permissionErr := controller.authorizationService.CheckRepositoryCanEdit(userID, req.GetOwnerName(), req.GetRepositoryName())
	if permissionErr != nil {
	logger.Sugar().Errorf("Error check permission: %v", permissionErr.Error())

	return nil, permissionErr
	}

	// 修改数据库
	err := controller.repositoryService.UpdateRepositorySettingsByName(ctx, req.GetOwnerName(), req.GetRepositoryName(), req.GetVisibility(), req.GetDescription())
	if err != nil {
	logger.Sugar().Errorf("Error update repo settings: %v", err.Error())

	return nil, err
	}

	resp := &registryv1alpha1.UpdateRepositorySettingsByNameResponse{}
	return resp, nil
	}

	func (controller RepositoryController) GetRepositoriesByFullName(ctx context.Context, req registryv1alpha1.GetRepositoriesByFullNameRequest) (*registryv1alpha1.GetRepositoriesByFullNameResponse, e.ResponseError) {
	retRepos := make([]*registryv1alpha1.Repository, 0, len(req.FullNames))
	for _, fullName := range req.GetFullNames() {
	// 验证参数
	userName, repositoryName, argErr := controller.validator.SplitFullName(fullName)
	if argErr != nil {
	logger.Sugar().Errorf("Error check: %v\n", argErr.Error())

	return nil, argErr
	}

	// 查询
	repository, err := controller.repositoryService.GetRepositoryByUserNameAndRepositoryName(ctx, userName, repositoryName)
	if err != nil {
	logger.Sugar().Errorf("Error get repo: %v\n", err.Error())

	return nil, err
	}
	retRepos = append(retRepos, repository.ToProtoRepository())
	}

	resp := &registryv1alpha1.GetRepositoriesByFullNameResponse{
	Repositories: retRepos,
	}

	return resp, nil
	}