feat(bitbucket): implement Bitbucket API service and ETL handler for repository management

Author: Ayyanaruto

backend/analytics_server/mhq/exapi/bitbucket.py

@@ -0,0 +1,126 @@
+import requests
+from typing import Optional, Dict, Any
+
+from mhq.utils.log import LOG
+from mhq.exapi.models.bitbucket import BitbucketRepo
+
+class BitbucketApiService:
+    def __init__(self, access_token: str):
+        self._token = access_token
+        self.base_url = "https://api.bitbucket.org/2.0"
+        self.headers = {"Authorization": f"Basic {self._token}"}
+        self.session = requests.Session()
+        self.session.headers.update(self.headers)
+    
+    def check_pat(self) -> bool:
+        """
+        Checks if Personal Access Token is valid.
+        
+        Returns:
+            bool: True if PAT is valid, False otherwise
+            
+        Raises:
+            requests.RequestException: If the request fails
+        """
+        url = f"{self.base_url}/user"
+        try:
+            response = self.session.get(url, timeout=30)
+            return response.status_code == 200
+        except requests.RequestException as e:
+            LOG.error(f"PAT validation failed: {e}")
+            raise requests.RequestException(f"PAT validation failed: {e}")
+        
+    def _handle_error(self, response: requests.Response) -> None:
+        """
+        Handle HTTP error responses from Bitbucket API.
+        
+        Args:
+            response: The HTTP response object
+            
+        Raises:
+            requests.HTTPError: If response status code is not 200
+        """
+        if response.status_code != 200:
+            try:
+                error_data = response.json()
+                error = error_data.get("error", "Unknown error")
+                message = error_data.get("message", "No message provided")
+            except ValueError:
+                error = "Invalid response format"
+                message = response.text or "No error details available"
+            
+            error_msg = f"Request failed with status {response.status_code}: {error} - {message}"
+            LOG.error(error_msg)
+            raise requests.HTTPError(error_msg)
+    
+    def get_workspace_repos(self, workspace: str, repo_slug: str) -> BitbucketRepo:
+        """
+        Get repository information for a specific workspace and repository.
+        
+        Args:
+            workspace: The workspace name
+            repo_slug: The repository slug
+            
+        Returns:
+             BitbucketRepo: Repository information object
+            
+        Raises:
+            requests.HTTPError: If the request fails
+            requests.RequestException: If the request encounters an error
+        """
+        url = f"{self.base_url}/repositories/{workspace}/{repo_slug}"
+        try:
+            response = self.session.get(url, timeout=30)
+            self._handle_error(response)
+            repo = response.json()
+            return BitbucketRepo(repo)
+        except requests.RequestException as e:
+            LOG.error(f"Failed to get repository {workspace}/{repo_slug}: {e}")
+            raise
+
+    def get_repo_contributors(self, workspace: str, repo_slug: str) -> Dict[str,int]:
+        """
+        Get all contributors for a repository with their contribution counts.
+        
+        Args:
+            workspace: The workspace name
+            repo_slug: The repository slug
+            
+        Returns:
+            dict: Dictionary with contributor names as keys and contribution counts as values
+            
+        Raises:
+            requests.HTTPError: If the request fails
+            requests.RequestException: If the request encounters an error
+        """
+        url = f"{self.base_url}/repositories/{workspace}/{repo_slug}/commits"
+        contributors = {}
+
+        try:
+            while url:
+                response = self.session.get(url, timeout=30)
+                self._handle_error(response)
+                
+                data = response.json()
+                commits = data.get('values', [])
+                
+                for commit in commits:
+                    author = commit.get('author', {})
+                    user = author.get('user', {})
+                    display_name = user.get('display_name', 'Unknown')
+                    
+                    if display_name in contributors:
+                        contributors[display_name] += 1
+                    else:
+                        contributors[display_name] = 1
+                
+                url = data.get('next')
+                
+            return contributors
+            
+        except requests.RequestException as e:
+            LOG.error(f"Failed to get contributors for {workspace}/{repo_slug}: {e}")
+            raise
+
+            
+

backend/analytics_server/mhq/exapi/models/bitbucket.py

@@ -0,0 +1,32 @@
+from dataclasses import dataclass
+from datetime import datetime
+from enum import Enum
+from typing import Dict, List, Optional
+
+from mhq.utils.time import dt_from_iso_time_string
+
+
+@dataclass
+class BitbucketRepo:
+    name: str
+    org_name: str
+    default_branch: str
+    idempotency_key: str
+    slug: str
+    description: str
+    web_url: str
+    languages: Optional[Dict] = None
+    contributors: Optional[List] = None
+
+    def __init__(self, repo: Dict):
+        self.name = repo.get("name", "")
+        self.org_name = repo.get("workspace", {}).get("name", "")
+        self.default_branch = repo.get("mainbranch", {}).get("name", "")
+        self.idempotency_key = str(repo.get("uuid", ""))
+        self.slug = repo.get("slug", "")
+        self.description = repo.get("description", "")
+        self.web_url = repo.get("links", {}).get("html", {}).get("href", "")
+        self.languages = repo.get("language")
+
+    def __hash__(self):
+        return hash(self.idempotency_key)

backend/analytics_server/mhq/service/code/integration.py

@@ -6,6 +6,7 @@
 CODE_INTEGRATION_BUCKET = [
     UserIdentityProvider.GITHUB.value,
     UserIdentityProvider.GITLAB.value,
+    UserIdentityProvider.BITBUCKET.value
 ]
 
 

backend/analytics_server/mhq/service/code/sync/etl_bitbucket_handler.py

@@ -0,0 +1,154 @@
+import uuid
+from datetime import datetime
+from typing import List, Dict, Optional, Tuple, Set
+
+import pytz
+
+from mhq.exapi.models.bitbucket import BitbucketRepo
+from mhq.exapi.bitbucket import BitbucketApiService
+from mhq.exapi.github import GithubApiService
+from mhq.service.code.sync.etl_code_analytics import CodeETLAnalyticsService
+from mhq.service.code.sync.etl_provider_handler import CodeProviderETLHandler
+from mhq.store.models import UserIdentityProvider
+from mhq.store.models.code import (
+    OrgRepo,
+    PullRequestState,
+    PullRequest,
+    PullRequestCommit,
+    PullRequestEvent,
+    PullRequestEventType,
+    PullRequestRevertPRMapping,
+    CodeProvider,
+)
+from mhq.store.repos.code import CodeRepoService
+from mhq.store.repos.core import CoreRepoService
+from mhq.utils.log import LOG
+from mhq.utils.time import time_now, ISO_8601_DATE_FORMAT
+
+PR_PROCESSING_CHUNK_SIZE = 100
+
+
+class BitbucketETLHandler(CodeProviderETLHandler):
+    """Handler for Bitbucket ETL operations."""
+    
+    def __init__(
+        self,
+        org_id: str,
+        bitbucket_api_service: BitbucketApiService,
+        code_repo_service: CodeRepoService,
+        code_etl_analytics_service: CodeETLAnalyticsService,
+        # bitbucket_revert_pr_sync_handler: RevertPRsGitHubSyncHandler,
+    ):
+        self.org_id = org_id
+        self._api = bitbucket_api_service
+        self.code_repo_service = code_repo_service
+        self.code_etl_analytics_service : CodeETLAnalyticsService = (
+            code_etl_analytics_service
+        )
+        self.provider = CodeProvider.BITBUCKET.value
+        # self.bitbucket_revert_pr_sync_handler: RevertPRsGitHubSyncHandler = (
+        #     github_revert_pr_sync_handler
+        # )
+
+    def check_pat_validity(self) -> bool:
+        """Check if the Bitbucket Personal Access Token is valid.
+        
+        Returns:
+            bool: True if the PAT is valid.
+            
+        Raises:
+            Exception: If the Bitbucket credentials are invalid.
+        """
+        is_valid = self._api.check_pat()
+        if not is_valid:
+            raise Exception("Bitbucket credentials are invalid. Please check username or password.")
+        return is_valid
+    
+    def get_org_repos(self, org_repos: List[OrgRepo]) -> List[OrgRepo]:
+        """Get organization repositories from Bitbucket API.
+        
+        Args:
+            org_repos: List of organization repositories to fetch.
+            
+        Returns:
+            List of processed OrgRepo objects.
+        """
+        bitbucket_repos: List[BitbucketRepo] = []
+        for org_repo in org_repos:
+            workspace = org_repo.org_name
+            repo_slug = org_repo.name
+            try:
+                bitbucket_repo = self._api.get_workspace_repos(workspace, repo_slug)
+                bitbucket_repos.append(bitbucket_repo)
+            except Exception as e:
+                LOG.error(f"Error getting Bitbucket repository {workspace}/{repo_slug}: {e}")
+                continue
+        repo_idempotency_key_org_repo_map = {
+            org_repo.idempotency_key: org_repo for org_repo in org_repos
+        }
+        
+        return [
+            self._process_bitbucket_repo(
+                repo_idempotency_key_org_repo_map.get(str(bitbucket_repo.idempotency_key)),
+                bitbucket_repo
+            )
+            for bitbucket_repo in bitbucket_repos
+            if repo_idempotency_key_org_repo_map.get(str(bitbucket_repo.idempotency_key))
+        ]
+
+    def _process_bitbucket_repo(
+        self, org_repo: OrgRepo, bitbucket_repo: BitbucketRepo
+    ) -> OrgRepo:
+        """Process a Bitbucket repository into an OrgRepo object.
+        
+        Args:
+            org_repo: Original organization repository.
+            bitbucket_repo: Bitbucket repository data.
+            
+        Returns:
+            Processed OrgRepo object.
+        """
+        return OrgRepo(
+            id=org_repo.id,
+            org_id=self.org_id,
+            name=bitbucket_repo.name,
+            provider=self.provider,
+            org_name=bitbucket_repo.org_name,
+            default_branch=bitbucket_repo.default_branch,
+            language=bitbucket_repo.languages,
+            contributors=self._api.get_repo_contributors(
+                bitbucket_repo.org_name, bitbucket_repo.name
+            ),
+            idempotency_key=str(bitbucket_repo.idempotency_key),
+            slug=bitbucket_repo.name,
+            updated_at=time_now(),
+        )
+
+
+
+def _get_access_token(org_id: str) -> Optional[str]:
+    """Retrieve access token for the given organization."""
+    core_repo_service = CoreRepoService()
+    access_token = core_repo_service.get_access_token(
+        org_id, UserIdentityProvider.BITBUCKET
+    )
+    
+    if not access_token:
+        LOG.error(
+            f"Access token not found for org {org_id} and provider "
+            f"{UserIdentityProvider.BITBUCKET.value}"
+        )
+    
+    return access_token
+
+
+def get_bitbucket_etl_handler(org_id: str) -> BitbucketETLHandler:
+    """Factory function to create a BitbucketETLHandler instance."""
+    access_token = _get_access_token(org_id)
+    
+    return BitbucketETLHandler(
+        org_id=org_id,
+        bitbucket_api_service=BitbucketApiService(access_token),
+        code_repo_service=CodeRepoService(),
+        code_etl_analytics_service=CodeETLAnalyticsService(),
+    )

backend/analytics_server/mhq/service/code/sync/etl_code_factory.py

@@ -1,5 +1,7 @@
+from mhq.utils.log import LOG
 from mhq.service.code.sync.etl_gitlab_handler import get_gitlab_etl_handler
 from mhq.service.code.sync.etl_github_handler import get_github_etl_handler
+from mhq.service.code.sync.etl_bitbucket_handler import get_bitbucket_etl_handler
 from mhq.service.code.sync.etl_provider_handler import CodeProviderETLHandler
 from mhq.store.models.code import CodeProvider
 
@@ -15,4 +17,7 @@ def __call__(self, provider: str) -> CodeProviderETLHandler:
         if provider == CodeProvider.GITLAB.value:
             return get_gitlab_etl_handler(self.org_id)
 
+        if provider == CodeProvider.BITBUCKET.value:
+            return get_bitbucket_etl_handler(self.org_id)
+
         raise NotImplementedError(f"Unknown provider - {provider}")

backend/analytics_server/mhq/store/models/integrations/enums.py

@@ -4,6 +4,7 @@
 class UserIdentityProvider(Enum):
     GITHUB = "github"
     GITLAB = "gitlab"
+    BITBUCKET = "bitbucket"
 
     @classmethod
     def get_enum(self, provider: str):