Add gitea-shim integration and update workflow services

gitea-shim/python/models/user.py

@@ -0,0 +1,246 @@
+"""User model that provides GitHub-compatible interface for Gitea users."""
+
+from typing import Optional, List, Dict, Any
+
+
+class User:
+    """
+    User wrapper that provides GitHub-compatible interface for Gitea users.
+    """
+    
+    def __init__(self, gitea_user, gitea_client):
+        """
+        Initialize user wrapper.
+        
+        Args:
+            gitea_user: The Gitea user object
+            gitea_client: The Gitea client instance
+        """
+        self._user = gitea_user
+        self._gitea = gitea_client
+        
+        # Map Gitea attributes to GitHub attributes
+        self.login = gitea_user.login
+        self.id = gitea_user.id
+        self.avatar_url = gitea_user.avatar_url
+        self.html_url = gitea_user.html_url
+        self.type = 'User'  # Could be 'User' or 'Organization'
+        self.name = gitea_user.full_name
+        self.company = getattr(gitea_user, 'company', None)
+        self.blog = getattr(gitea_user, 'website', None)
+        self.location = gitea_user.location
+        self.email = gitea_user.email
+        self.bio = getattr(gitea_user, 'description', None)
+        self.public_repos = getattr(gitea_user, 'public_repos', 0)
+        self.followers = getattr(gitea_user, 'followers_count', 0)
+        self.following = getattr(gitea_user, 'following_count', 0)
+        self.created_at = gitea_user.created
+        self.updated_at = getattr(gitea_user, 'last_login', gitea_user.created)
+        
+    def get_repos(self, type: str = 'owner', sort: str = 'full_name',
+                  direction: str = 'asc') -> List[Any]:
+        """
+        Get repositories for the user.
+        
+        Args:
+            type: Type of repos to return ('all', 'owner', 'member')
+            sort: Sort field ('created', 'updated', 'pushed', 'full_name')
+            direction: Sort direction ('asc', 'desc')
+            
+        Returns:
+            List of Repository objects
+        """
+        # Import here to avoid circular imports
+        try:
+            # When running tests or using as a module
+            from models.repository import Repository
+        except ImportError:
+            # When using as a package
+            from .repository import Repository
+        
+        # Get repos using Gitea API
+        gitea_repos = self._user.get_repos()
+        
+        # Convert to Repository objects
+        repos = [Repository(repo, self._gitea) for repo in gitea_repos]
+        
+        # Apply sorting
+        if sort == 'full_name':
+            repos.sort(key=lambda r: r.full_name, reverse=(direction == 'desc'))
+        elif sort == 'created':
+            repos.sort(key=lambda r: r.created_at, reverse=(direction == 'desc'))
+        elif sort == 'updated':
+            repos.sort(key=lambda r: r.updated_at, reverse=(direction == 'desc'))
+            
+        return repos
+    
+    def get_starred(self) -> List[Any]:
+        """
+        Get repositories starred by the user.
+        
+        Returns:
+            List of Repository objects
+        """
+        # Import here to avoid circular imports
+        try:
+            # When running tests or using as a module
+            from models.repository import Repository
+        except ImportError:
+            # When using as a package
+            from .repository import Repository
+        
+        # Get starred repos using Gitea API
+        gitea_repos = self._user.get_starred()
+        
+        # Convert to Repository objects
+        return [Repository(repo, self._gitea) for repo in gitea_repos]
+    
+    def get_subscriptions(self) -> List[Any]:
+        """
+        Get repositories watched by the user.
+        
+        Returns:
+            List of Repository objects
+        """
+        # Import here to avoid circular imports
+        try:
+            # When running tests or using as a module
+            from models.repository import Repository
+        except ImportError:
+            # When using as a package
+            from .repository import Repository
+        
+        # Get watched repos using Gitea API
+        gitea_repos = self._user.get_subscriptions()
+        
+        # Convert to Repository objects
+        return [Repository(repo, self._gitea) for repo in gitea_repos]
+    
+    def get_orgs(self) -> List[Dict[str, Any]]:
+        """
+        Get organizations the user belongs to.
+        
+        Returns:
+            List of organization objects
+        """
+        gitea_orgs = self._user.get_orgs()
+        
+        orgs = []
+        for org in gitea_orgs:
+            orgs.append({
+                'login': org.username,
+                'id': org.id,
+                'avatar_url': org.avatar_url,
+                'description': org.description,
+                'type': 'Organization'
+            })
+            
+        return orgs
+    
+    def get_followers(self) -> List['User']:
+        """
+        Get users following this user.
+        
+        Returns:
+            List of User objects
+        """
+        gitea_followers = self._user.get_followers()
+        
+        # Convert to User objects
+        return [User(follower, self._gitea) for follower in gitea_followers]
+    
+    def get_following(self) -> List['User']:
+        """
+        Get users this user is following.
+        
+        Returns:
+            List of User objects
+        """
+        gitea_following = self._user.get_following()
+        
+        # Convert to User objects
+        return [User(user, self._gitea) for user in gitea_following]
+    
+    def has_in_following(self, following: 'User') -> bool:
+        """
+        Check if this user follows another user.
+        
+        Args:
+            following: User to check
+            
+        Returns:
+            True if following, False otherwise
+        """
+        return self._user.is_following(following.login)
+    
+    def add_to_following(self, following: 'User') -> None:
+        """
+        Follow another user.
+        
+        Args:
+            following: User to follow
+        """
+        self._user.follow(following.login)
+    
+    def remove_from_following(self, following: 'User') -> None:
+        """
+        Unfollow another user.
+        
+        Args:
+            following: User to unfollow
+        """
+        self._user.unfollow(following.login)
+    
+    def get_keys(self) -> List[Dict[str, Any]]:
+        """
+        Get SSH keys for the user.
+        
+        Returns:
+            List of key objects
+        """
+        gitea_keys = self._user.get_keys()
+        
+        keys = []
+        for key in gitea_keys:
+            keys.append({
+                'id': key.id,
+                'key': key.key,
+                'title': key.title,
+                'created_at': key.created_at,
+                'read_only': getattr(key, 'read_only', True)
+            })
+            
+        return keys
+    
+    def create_repo(self, name: str, **kwargs) -> Any:
+        """
+        Create a new repository for the user.
+        
+        Args:
+            name: Repository name
+            **kwargs: Additional parameters
+            
+        Returns:
+            Repository object
+        """
+        # Import here to avoid circular imports
+        try:
+            # When running tests or using as a module
+            from models.repository import Repository
+        except ImportError:
+            # When using as a package
+            from .repository import Repository
+        
+        # Map GitHub parameters to Gitea parameters
+        gitea_params = {
+            'name': name,
+            'description': kwargs.get('description', ''),
+            'private': kwargs.get('private', False),
+            'auto_init': kwargs.get('auto_init', False),
+            'gitignores': kwargs.get('gitignore_template', ''),
+            'license': kwargs.get('license_template', ''),
+            'readme': kwargs.get('readme', '')
+        }
+        
+        gitea_repo = self._user.create_repo(**gitea_params)
+        return Repository(gitea_repo, self._gitea)