Merge pull request #3892 from communitybridge/bug/gitlab_certificate_…

…reactivate

Bug/gitlab certificate reactivate

cla-backend-go/cmd/dynamo_events_lambda/main.go

@@ -137,7 +137,7 @@ func init() {
 	usersService := users.NewService(usersRepo, eventsService)
 	signaturesRepo := signatures.NewRepository(awsSession, stage, companyRepo, usersRepo, eventsService, repositoriesRepo, githubOrganizationsRepo, gerritService)
 	v2RepositoryService := v2Repositories.NewService(repositoriesRepo, v2Repository, projectClaGroupRepo, githubOrganizationsRepo, gitlabOrganizationRepo, eventsService)
-	gitlabOrgService := gitlab_organizations.NewService(gitlabOrganizationRepo, v2RepositoryService, projectClaGroupRepo, storeRepo, usersService)
+	gitlabOrgService := gitlab_organizations.NewService(gitlabOrganizationRepo, v2RepositoryService, projectClaGroupRepo, storeRepo, usersService, signaturesRepo, companyRepo)
 
 	companyService := company.NewService(companyRepo, configFile.CorporateConsoleV1URL, userRepo, usersService)
 	v2CompanyService := v2Company.NewService(companyService, signaturesRepo, projectRepo, usersRepo, companyRepo, projectClaGroupRepo, eventsService)

cla-backend-go/cmd/gitlab_repository_check/handler/handler.go

@@ -8,6 +8,7 @@ import (
 	"os"
 	"strconv"
 
+	"github.com/communitybridge/easycla/cla-backend-go/signatures"
 	"github.com/communitybridge/easycla/cla-backend-go/v2/common"
 
 	"github.com/communitybridge/easycla/cla-backend-go/project/repository"
@@ -135,11 +136,18 @@ func Handler(ctx context.Context) error {
 		v1ProjectClaGroupRepo,
 	})
 
-	usersService := users.NewService(usersRepo, eventsService)
+	gerritService := gerrits.NewService(gerritRepo, &gerrits.LFGroup{
+		LfBaseURL:    configFile.LFGroup.ClientURL,
+		ClientID:     configFile.LFGroup.ClientID,
+		ClientSecret: configFile.LFGroup.ClientSecret,
+		RefreshToken: configFile.LFGroup.RefreshToken,
+	})
 
+	usersService := users.NewService(usersRepo, eventsService)
+	signaturesRepo := signatures.NewRepository(awsSession, stage, v1CompanyRepo, usersRepo, eventsService, gitV1Repository, githubOrganizationsRepo, gerritService)
 	v2RepositoriesService := v2Repositories.NewService(gitV1Repository, gitV2Repository, v1ProjectClaGroupRepo, githubOrganizationsRepo, gitlabOrganizationRepo, eventsService)
 	// gitlabOrganizationsService := gitlab_organizations.NewService(gitlabOrganizationRepo, v2RepositoriesService, v1ProjectClaGroupRepo)
-	gitlabOrganizationService := gitlab_organizations.NewService(gitlabOrganizationRepo, v2RepositoriesService, v1ProjectClaGroupRepo, storeRepo, usersService)
+	gitlabOrganizationService := gitlab_organizations.NewService(gitlabOrganizationRepo, v2RepositoriesService, v1ProjectClaGroupRepo, storeRepo, usersService, signaturesRepo, v1CompanyRepo)
 
 	// Query GitLab Groups
 	// for each group

cla-backend-go/cmd/server.go

@@ -303,7 +303,7 @@ func server(localMode bool) http.Handler {
 	v1RepositoriesService := v1Repositories.NewService(gitV1Repository, githubOrganizationsRepo, v1ProjectClaGroupRepo)
 	v2RepositoriesService := v2Repositories.NewService(gitV1Repository, gitV2Repository, v1ProjectClaGroupRepo, githubOrganizationsRepo, gitlabOrganizationRepo, eventsService)
 	githubOrganizationsService := github_organizations.NewService(githubOrganizationsRepo, gitV1Repository, v1ProjectClaGroupRepo)
-	gitlabOrganizationsService := gitlab_organizations.NewService(gitlabOrganizationRepo, v2RepositoriesService, v1ProjectClaGroupRepo, storeRepository, usersService)
+	gitlabOrganizationsService := gitlab_organizations.NewService(gitlabOrganizationRepo, v2RepositoriesService, v1ProjectClaGroupRepo, storeRepository, usersService, signaturesRepo, v1CompanyRepo)
 	v1SignaturesService := signatures.NewService(signaturesRepo, v1CompanyService, usersService, eventsService, githubOrgValidation, v1RepositoriesService, githubOrganizationsService, v1ProjectService, gitlabApp, configFile.ClaV1ApiURL, configFile.CLALandingPage, configFile.CLALogoURL)
 	v2SignatureService := v2Signatures.NewService(awsSession, configFile.SignatureFilesBucket, v1ProjectService, v1CompanyService, v1SignaturesService, v1ProjectClaGroupRepo, signaturesRepo, usersService)
 	v1ClaManagerService := cla_manager.NewService(claManagerReqRepo, v1ProjectClaGroupRepo, v1CompanyService, v1ProjectService, usersService, v1SignaturesService, eventsService, emailTemplateService, configFile.CorporateConsoleV1URL)

cla-backend-go/company/repository.go

@@ -41,16 +41,13 @@ type IRepository interface { //nolint
 	DeleteCompanyBySFID(ctx context.Context, companySFID string) error
 	GetCompaniesByUserManager(ctx context.Context, userID string, userModel user.User) (*models.Companies, error)
 	GetCompaniesByUserManagerWithInvites(ctx context.Context, userID string, userModel user.User) (*models.CompaniesWithInvites, error)
-
 	AddPendingCompanyInviteRequest(ctx context.Context, companyID string, userModel user.User) (*Invite, error)
 	GetCompanyInviteRequest(ctx context.Context, companyInviteID string) (*Invite, error)
 	GetCompanyInviteRequests(ctx context.Context, companyID string, status *string) ([]Invite, error)
 	GetCompanyUserInviteRequests(ctx context.Context, companyID string, userID string) (*Invite, error)
 	GetUserInviteRequests(ctx context.Context, userID string) ([]Invite, error)
 	ApproveCompanyAccessRequest(ctx context.Context, companyInviteID string) error
 	RejectCompanyAccessRequest(ctx context.Context, companyInviteID string) error
-	updateInviteRequestStatus(ctx context.Context, companyInviteID, status string) error
-
 	UpdateCompanyAccessList(ctx context.Context, companyID string, companyACL []string) error
 }
 

cla-backend-go/repositories/repository.go

@@ -86,14 +86,32 @@ func (r *Repository) GitHubAddRepository(ctx context.Context, externalProjectID
 	}
 
 	// Check first to see if the repository already exists
-	_, err := r.GitHubGetRepositoryByGithubID(ctx, utils.StringValue(input.RepositoryExternalID), true)
+	repo, err := r.GitHubGetRepositoryByExternalID(ctx, utils.StringValue(input.RepositoryExternalID))
 	if err != nil {
 		// Expecting Not found - no issue if not found - all other error we throw
 		if _, ok := err.(*utils.GitHubRepositoryNotFound); !ok {
 			return nil, err
 		}
 	} else {
-		return nil, errors.New("github repository already exist")
+		if repo.Enabled {
+			return nil, errors.New("github repository already exist")
+		}
+		// Here repository already exists. We update the same repository with latest document in order to avoid duplicate entries.
+		var enabled = true
+		var repository *models.GithubRepository
+		repository, err = r.GitHubUpdateRepository(ctx, repo.RepositoryID, projectSFID, externalProjectID, &models.GithubRepositoryInput{
+			RepositoryName:             input.RepositoryName,
+			RepositoryOrganizationName: input.RepositoryOrganizationName,
+			RepositoryProjectID:        input.RepositoryProjectID,
+			Enabled:                    &enabled,
+			RepositoryType:             input.RepositoryType,
+			RepositoryURL:              input.RepositoryURL,
+			Note:                       "Disabled repository enabled and updated",
+		})
+		if err != nil {
+			return nil, err
+		}
+		return repository, nil
 	}
 
 	_, currentTime := utils.CurrentTime()
@@ -801,6 +819,7 @@ func (r *Repository) GitHubGetRepositoryByGithubID(ctx context.Context, external
 	var result *RepositoryDBModel
 	if len(results.Items) == 0 {
 		msg := fmt.Sprintf("no repository found matching external repository ID: %s", externalID)
+		log.WithFields(f).Warn(msg)
 		return nil, &utils.GitHubRepositoryNotFound{
 			Message: msg,
 		}

cla-backend-go/signatures/repository.go

@@ -82,25 +82,20 @@ type SignatureRepository interface {
 	GetProjectCompanyEmployeeSignatures(ctx context.Context, params signatures.GetProjectCompanyEmployeeSignaturesParams, criteria *ApprovalCriteria) (*models.Signatures, error)
 	GetProjectCompanyEmployeeSignature(ctx context.Context, companyModel *models.Company, claGroupModel *models.ClaGroup, employeeUserModel *models.User) (*models.Signature, error)
 	CreateProjectCompanyEmployeeSignature(ctx context.Context, companyModel *models.Company, claGroupModel *models.ClaGroup, employeeUserModel *models.User) error
-	getProjectCompanyEmployeeSignatureCount(ctx context.Context, params signatures.GetProjectCompanyEmployeeSignaturesParams, criteria *ApprovalCriteria, responseChannel chan int64)
 	GetCompanySignatures(ctx context.Context, params signatures.GetCompanySignaturesParams, pageSize int64, loadACL bool) (*models.Signatures, error)
 	GetCompanyIDsWithSignedCorporateSignatures(ctx context.Context, claGroupID string) ([]SignatureCompanyID, error)
 	GetUserSignatures(ctx context.Context, params signatures.GetUserSignaturesParams, pageSize int64) (*models.Signatures, error)
 	ProjectSignatures(ctx context.Context, projectID string) (*models.Signatures, error)
 	UpdateApprovalList(ctx context.Context, claManager *models.User, claGroupModel *models.ClaGroup, companyID string, params *models.ApprovalList, eventArgs *events.LogEventArgs) (*models.Signature, error)
-
 	AddCLAManager(ctx context.Context, signatureID, claManagerID string) (*models.Signature, error)
 	RemoveCLAManager(ctx context.Context, signatureID, claManagerID string) (*models.Signature, error)
-
-	removeColumn(ctx context.Context, signatureID, columnName string) (*models.Signature, error)
-
 	AddSigTypeSignedApprovedID(ctx context.Context, signatureID string, val string) error
 	AddUsersDetails(ctx context.Context, signatureID string, userID string) error
 	AddSignedOn(ctx context.Context, signatureID string) error
-
 	GetClaGroupICLASignatures(ctx context.Context, claGroupID string, searchTerm *string, approved, signed *bool, pageSize int64, nextKey string, withExtraDetails bool) (*models.IclaSignatures, error)
 	GetClaGroupCorporateContributors(ctx context.Context, claGroupID string, companyID *string, pageSize *int64, nextKey *string, searchTerm *string) (*models.CorporateContributorList, error)
 	EclaAutoCreate(ctx context.Context, signatureID string, autoCreateECLA bool) error
+	ActivateSignature(ctx context.Context, signatureID string) error
 }
 
 type iclaSignatureWithDetails struct {
@@ -4096,6 +4091,44 @@ func (repo repository) EclaAutoCreate(ctx context.Context, signatureID string, a
 	return nil
 }
 
+// ActivateSignature used to activate signature again, in case of deactivated signature found
+func (repo repository) ActivateSignature(ctx context.Context, signatureID string) error {
+	f := logrus.Fields{
+		"functionName":   "v1.signature.repository.ActivateSignature",
+		utils.XREQUESTID: ctx.Value(utils.XREQUESTID),
+		"signatureID":    signatureID,
+	}
+
+	// Build the expression
+	expressionUpdate := expression.Set(expression.Name("signature_approved"), expression.Value(true)).Set(expression.Name("signature_signed"), expression.Value(false))
+
+	expr, err := expression.NewBuilder().WithUpdate(expressionUpdate).Build()
+	if err != nil {
+		log.WithFields(f).Warnf("error building expression for signature: %s, error: %v", signatureID, err)
+		return err
+	}
+
+	input := &dynamodb.UpdateItemInput{
+		ExpressionAttributeNames:  expr.Names(),
+		ExpressionAttributeValues: expr.Values(),
+		Key: map[string]*dynamodb.AttributeValue{
+			"signature_id": {
+				S: aws.String(signatureID),
+			},
+		},
+		ConditionExpression: expr.KeyCondition(),
+		TableName:           aws.String(repo.signatureTableName),
+		UpdateExpression:    expr.Update(),
+	}
+
+	_, updateErr := repo.dynamoDBClient.UpdateItem(input)
+	if updateErr != nil {
+		log.WithFields(f).Warnf("error updating signature: %s, error: %v", signatureID, updateErr)
+		return updateErr
+	}
+	return nil
+}
+
 // getGerritUsers is a helper function to fetch the list of gerrit users for the specified type - results are returned through the specified results channel
 func (repo repository) getGerritUsers(ctx context.Context, authUser *auth.User, projectSFID string, claType string, gerritResultChannel chan *GerritUserResponse) {
 	f := logrus.Fields{

cla-backend-go/v2/gitlab_organizations/service.go

@@ -17,6 +17,9 @@ import (
 
 	"time"
 
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/communitybridge/easycla/cla-backend-go/company"
+	"github.com/communitybridge/easycla/cla-backend-go/signatures"
 	"github.com/communitybridge/easycla/cla-backend-go/users"
 	"github.com/communitybridge/easycla/cla-backend-go/v2/repositories"
 
@@ -70,17 +73,21 @@ type Service struct {
 	gitLabApp          *gitlabApi.App
 	storeRepo          store.Repository
 	userService        users.Service
+	signatureRepo      signatures.SignatureRepository
+	companyRepository  company.IRepository
 }
 
 // NewService creates a new gitlab organization service
-func NewService(repo RepositoryInterface, v2GitRepoService repositories.ServiceInterface, claGroupRepository projects_cla_groups.Repository, storeRepo store.Repository, userService users.Service) ServiceInterface {
+func NewService(repo RepositoryInterface, v2GitRepoService repositories.ServiceInterface, claGroupRepository projects_cla_groups.Repository, storeRepo store.Repository, userService users.Service, signaturesRepo signatures.SignatureRepository, companyRepository company.IRepository) ServiceInterface {
 	return &Service{
 		repo:               repo,
 		v2GitRepoService:   v2GitRepoService,
 		claGroupRepository: claGroupRepository,
 		gitLabApp:          gitlabApi.Init(config.GetConfig().Gitlab.AppClientID, config.GetConfig().Gitlab.AppClientSecret, config.GetConfig().Gitlab.AppPrivateKey),
 		userService:        userService,
 		storeRepo:          storeRepo,
+		signatureRepo:      signaturesRepo,
+		companyRepository:  companyRepository,
 	}
 }
 
@@ -835,7 +842,49 @@ func (s *Service) InitiateSignRequest(ctx context.Context, req *http.Request, gi
 		log.WithFields(f).Warn(msg)
 		return nil, err
 	}
+	var signatureID string
+	icla, signErr := s.signatureRepo.GetIndividualSignature(ctx, gitlabRepo.RepositoryClaGroupID, claUser.UserID, aws.Bool(false), aws.Bool(true))
+	if signErr != nil {
+		log.WithFields(f).WithError(signErr).Warnf("problem checking for ICLA signature for user: %s", claUser.UserID)
+	}
+	if icla != nil && icla.SignatureID != "" {
+		log.WithFields(f).Infof("loaded individual signature id: %s for claGroupID: %s and UserID: %s", icla.SignatureID, gitlabRepo.RepositoryClaGroupID, claUser.UserID)
+		signatureID = icla.SignatureID
+	} else {
+		log.WithFields(f).Debugf("ICLA signature check failed for user: %+v on project: %s - ICLA not signed", claUser, gitlabRepo.RepositoryClaGroupID)
+		if claUser.CompanyID == "" {
+			log.WithFields(f).Debugf("user does not have association with any company, can't confirm employee acknoledgement")
+			return &consoleURL, nil
+		}
 
+		companyID := claUser.CompanyID
+		_, err = s.companyRepository.GetCompany(ctx, companyID)
+		if err != nil {
+			msg := fmt.Sprintf("can't load company record: %s for user: %s (%s), error: %v", companyID, claUser.Username, claUser.UserID, err)
+			log.WithFields(f).Errorf(msg)
+			return &consoleURL, nil
+		}
+
+		corporateSignature, err := s.signatureRepo.GetCorporateSignature(ctx, gitlabRepo.RepositoryClaGroupID, companyID, aws.Bool(false), aws.Bool(true))
+		if err != nil {
+			msg := fmt.Sprintf("can't load company signature record for company: %s for user : %s (%s), error : %v", companyID, claUser.Username, claUser.UserID, err)
+			log.WithFields(f).Errorf(msg)
+			return &consoleURL, nil
+		}
+
+		if corporateSignature == nil {
+			msg := fmt.Sprintf("no corporate signature (CCLA) record found for company : %s ", companyID)
+			log.WithFields(f).Errorf(msg)
+			return &consoleURL, nil
+		}
+		log.WithFields(f).Debugf("loaded corporate signature id: %s for claGroupID: %s and companyID: %s", corporateSignature.SignatureID, gitlabRepo.RepositoryClaGroupID, companyID)
+		signatureID = corporateSignature.SignatureID
+	}
+	err = s.signatureRepo.ActivateSignature(ctx, signatureID)
+	if err != nil {
+		msg := fmt.Sprintf("found error on Activate Signature error : %s", err.Error())
+		log.WithFields(f).Errorf(msg)
+	}
 	return &consoleURL, nil
 }