Add delete github integration api

Author: czezi

app/controllers/github_integration_controller.go

@@ -1,7 +1,9 @@
 package controllers
 
 import (
+	"ai-developer/app/config"
 	"ai-developer/app/services/integrations"
+	"fmt"
 	"github.com/gin-gonic/gin"
 	"go.uber.org/zap"
 	"net/http"
@@ -22,6 +24,16 @@ func (gic *GithubIntegrationController) Authorize(c *gin.Context) {
 	c.Redirect(http.StatusTemporaryRedirect, authCodeUrl)
 }
 
+func (gic *GithubIntegrationController) DeleteIntegration(c *gin.Context) {
+	userId, _ := c.Get("user_id")
+	err := gic.githubIntegrationService.DeleteIntegration(uint64(userId.(int)))
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+		return
+	}
+	c.JSON(http.StatusOK, gin.H{"message": "Integration deleted successfully"})
+}
+
 func (gic *GithubIntegrationController) CheckIfIntegrationExists(c *gin.Context) {
 	userId, _ := c.Get("user_id")
 	hasIntegration, err := gic.githubIntegrationService.HasGithubIntegration(uint64(userId.(int)))
@@ -60,14 +72,9 @@ func (gic *GithubIntegrationController) HandleCallback(c *gin.Context) {
 		zap.String("state", state),
 	)
 
-	err := gic.githubIntegrationService.GenerateAndSaveAccessToken(code, state)
-	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	} else {
-		c.JSON(http.StatusOK, gin.H{"message": "Integration successful"})
-		return
-	}
+	_ = gic.githubIntegrationService.GenerateAndSaveAccessToken(code, state)
+	redirectUrl := fmt.Sprintf("%s/settings?page=integrations", config.GithubFrontendURL())
+	c.Redirect(http.StatusTemporaryRedirect, redirectUrl)
 }
 
 func NewGithubIntegrationController(

app/controllers/project_controller.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+	"ai-developer/app/models"
 	"ai-developer/app/services"
 	"ai-developer/app/types/request"
 	"net/http"
@@ -56,8 +57,8 @@ func (controller *ProjectController) GetProjectById(context *gin.Context) {
 	context.JSON(http.StatusOK, project)
 }
 
-func (controller *ProjectController) CreateProjectFromGit(context *gin.Context) {
-	var createProjectRequest request.CreateProjectFromGitRequest
+func (controller *ProjectController) CreateProject(context *gin.Context) {
+	var createProjectRequest request.CreateProjectRequest
 	if err := context.ShouldBindJSON(&createProjectRequest); err != nil {
 		context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
 		return
@@ -73,44 +74,13 @@ func (controller *ProjectController) CreateProjectFromGit(context *gin.Context)
 		return
 	}
 
-	project, err := controller.projectService.CreateProjectFromGit(user.ID, user.OrganisationID, createProjectRequest)
-	if err != nil {
-		context.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
+	var project *models.Project
+	if createProjectRequest.Repository == nil {
+		project, err = controller.projectService.CreateProject(int(user.OrganisationID), createProjectRequest)
+	} else {
+		project, err = controller.projectService.CreateProjectFromGit(user.ID, user.OrganisationID, createProjectRequest)
 	}
 
-	context.JSON(
-		http.StatusOK,
-		gin.H{
-			"project_id":                 project.ID,
-			"project_url":                project.Url,
-			"project_name":               project.Name,
-			"project_frontend_url":       project.FrontendURL,
-			"project_backend_url":        project.BackendURL,
-			"project_framework":          project.BackendFramework,
-			"project_frontend_framework": project.FrontendFramework,
-		},
-	)
-	return
-}
-
-func (controller *ProjectController) CreateProject(context *gin.Context) {
-	var createProjectRequest request.CreateProjectRequest
-	if err := context.ShouldBindJSON(&createProjectRequest); err != nil {
-		context.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
-		return
-	}
-	email, _ := context.Get("email")
-	user, err := controller.userService.GetUserByEmail(email.(string))
-	if err != nil {
-		context.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
-		return
-	}
-	if user == nil {
-		context.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": "User not found"})
-		return
-	}
-	project, err := controller.projectService.CreateProject(int(user.OrganisationID), createProjectRequest)
 	if err != nil {
 		context.AbortWithStatusJSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
 		return

app/repositories/integrations.go

@@ -24,6 +24,22 @@ func (ir *IntegrationsRepository) FindIntegrationIdByUserIdAndType(userId uint64
 	return
 }
 
+func (ir *IntegrationsRepository) DeleteIntegration(userId uint64, integrationType string) (err error) {
+	ir.logger.Info(
+		"Deleting integration",
+		zap.Uint64("userId", userId),
+		zap.String("integrationType", integrationType),
+	)
+	err = ir.db.Unscoped().Where(&models.Integration{
+		UserId:          userId,
+		IntegrationType: integrationType,
+	}).Delete(&models.Integration{
+		UserId:          userId,
+		IntegrationType: integrationType,
+	}).Error
+	return
+}
+
 func (ir *IntegrationsRepository) AddOrUpdateIntegration(
 	userId uint64,
 	integrationType string,

app/services/integrations/github_integration_service.go

@@ -5,11 +5,13 @@ import (
 	"ai-developer/app/models/dtos/integrations"
 	"ai-developer/app/utils"
 	"context"
+	"errors"
 	"fmt"
 	"github.com/google/go-github/github"
 	"go.uber.org/zap"
 	"golang.org/x/oauth2"
 	githubOAuth "golang.org/x/oauth2/github"
+	"gorm.io/gorm"
 	"strconv"
 )
 
@@ -22,12 +24,20 @@ type GithubIntegrationService struct {
 	integrationService *IntegrationService
 }
 
+func (gis *GithubIntegrationService) DeleteIntegration(userId uint64) (err error) {
+	err = gis.integrationService.DeleteIntegration(userId, GithubIntegrationType)
+	return
+}
+
 func (gis *GithubIntegrationService) GetRedirectUrl(userId uint64) string {
 	return gis.oauthConfig.AuthCodeURL(fmt.Sprintf("%d", userId), oauth2.AccessTypeOnline)
 }
 
 func (gis *GithubIntegrationService) HasGithubIntegration(userId uint64) (hasIntegration bool, err error) {
 	integration, err := gis.integrationService.FindIntegrationIdByUserIdAndType(userId, GithubIntegrationType)
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return false, nil
+	}
 	if err != nil {
 		return
 	}
@@ -37,7 +47,11 @@ func (gis *GithubIntegrationService) HasGithubIntegration(userId uint64) (hasInt
 
 func (gis *GithubIntegrationService) GetRepositories(userId uint64) (repos []*github.Repository, err error) {
 	integration, err := gis.integrationService.FindIntegrationIdByUserIdAndType(userId, GithubIntegrationType)
-	if err != nil || integration == nil {
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		return make([]*github.Repository, 0), nil
+	}
+
+	if err != nil {
 		return
 	}
 

app/services/integrations/integration_service.go

@@ -16,6 +16,10 @@ func (is *IntegrationService) FindIntegrationIdByUserIdAndType(userId uint64, in
 	return is.integrationsRepository.FindIntegrationIdByUserIdAndType(userId, integrationType)
 }
 
+func (is *IntegrationService) DeleteIntegration(userId uint64, integrationType string) (err error) {
+	return is.integrationsRepository.DeleteIntegration(userId, integrationType)
+}
+
 func (is *IntegrationService) AddOrUpdateIntegration(
 	userId uint64,
 	integrationType string,

app/services/project_service.go

@@ -84,7 +84,7 @@ func (s *ProjectService) GetProjectDetailsById(projectId int) (*models.Project,
 	return project, nil
 }
 
-func (s *ProjectService) CreateProjectFromGit(userId uint, orgId uint, requestData request.CreateProjectFromGitRequest) (project *models.Project, err error) {
+func (s *ProjectService) CreateProjectFromGit(userId uint, orgId uint, requestData request.CreateProjectRequest) (project *models.Project, err error) {
 	integrationDetails, err := s.githubIntegrationService.GetGithubIntegrationDetails(uint64(userId))
 	if err != nil {
 		s.logger.Error("Error getting github integration details", zap.Error(err))
@@ -132,7 +132,7 @@ func (s *ProjectService) CreateProjectFromGit(userId uint, orgId uint, requestDa
 	_, err = s.workspaceServiceClient.ImportGitRepository(
 		&request.ImportGitRepository{
 			WorkspaceId:  hashID,
-			Repository:   requestData.Repository,
+			Repository:   *requestData.Repository,
 			Username:     integrationDetails.GithubUserId,
 			Password:     integrationDetails.AccessToken,
 			RemoteURL:    remoteGitURL,

app/types/request/create_project_request.go

@@ -1,16 +1,9 @@
 package request
 
 type CreateProjectRequest struct {
-	Name              string `json:"name"`
-	Framework         string `json:"framework"`
-	FrontendFramework string `json:"frontend_framework"`
-	Description       string `json:"description"`
-}
-
-type CreateProjectFromGitRequest struct {
-	Name              string `json:"name"`
-	Framework         string `json:"framework"`
-	FrontendFramework string `json:"frontend_framework"`
-	Description       string `json:"description"`
-	Repository        string `json:"repository"`
+	Name              string  `json:"name"`
+	Framework         string  `json:"framework"`
+	FrontendFramework string  `json:"frontend_framework"`
+	Description       string  `json:"description"`
+	Repository        *string `json:"repository"`
 }

server.go

@@ -479,8 +479,6 @@ func main() {
 		projects.POST("", projectsController.CreateProject)
 		projects.PUT("", projectsController.UpdateProject)
 
-		projects.POST("/import", projectsController.CreateProjectFromGit)
-
 		projects.GET("/", projectsController.GetAllProjects)
 		projects.POST("/", projectsController.CreateProject)
 		projects.PUT("/", projectsController.UpdateProject)
@@ -550,7 +548,10 @@ func main() {
 		integrations := api.Group("/integrations", middleware.AuthenticateJWT())
 
 		githubIntegration := integrations.Group("/github")
+
 		githubIntegration.GET("", githubIntegrationController.CheckIfIntegrationExists)
+		githubIntegration.DELETE("", githubIntegrationController.DeleteIntegration)
+
 		githubIntegration.GET("/repos", githubIntegrationController.GetRepositories)
 		githubIntegration.GET("/authorize", githubIntegrationController.Authorize)
 		githubIntegration.GET("/callback", githubIntegrationController.HandleCallback)

worker.go

@@ -6,10 +6,12 @@ import (
 	"ai-developer/app/client/workspace"
 	"ai-developer/app/config"
 	"ai-developer/app/constants"
+	"ai-developer/app/controllers"
 	"ai-developer/app/monitoring"
 	"ai-developer/app/repositories"
 	"ai-developer/app/services"
 	"ai-developer/app/services/git_providers"
+	"ai-developer/app/services/integrations"
 	"ai-developer/app/services/s3_providers"
 	"ai-developer/app/tasks"
 	"context"
@@ -266,6 +268,36 @@ func main() {
 		}, nil)
 	})
 
+	// Integration
+	{
+		if err = c.Provide(repositories.NewIntegrationsRepository); err != nil {
+			config.Logger.Error("Error providing IntegrationsRepository", zap.Error(err))
+			panic(err)
+		}
+		if err = c.Provide(integrations.NewIntegrationService); err != nil {
+			config.Logger.Error("Error providing IntegrationService", zap.Error(err))
+			panic(err)
+		}
+	}
+
+	// Github Integration
+	{
+		if err = c.Provide(config.NewGithubIntegrationConfig); err != nil {
+			config.Logger.Error("Error providing GithubIntegrationConfig", zap.Error(err))
+			panic(err)
+		}
+
+		if err = c.Provide(integrations.NewGithubIntegrationService); err != nil {
+			config.Logger.Error("Error providing GithubIntegrationService", zap.Error(err))
+			panic(err)
+		}
+
+		if err = c.Provide(controllers.NewGithubIntegrationController); err != nil {
+			config.Logger.Error("Error providing GithubIntegrationController", zap.Error(err))
+			panic(err)
+		}
+	}
+
 	err = c.Provide(func(
 		deleteWorkspaceTaskHandler *tasks.DeleteWorkspaceTaskHandler,
 		createExecutionJobTaskHandler *tasks.CreateExecutionJobTaskHandler,