Add helper functions for Version

helpers/version_helpers.py

@@ -0,0 +1,128 @@
+from typing import Optional, Dict, Union
+import re
+from datetime import datetime
+from sqlalchemy.orm import Session
+from models.version import Version
+from schemas.version import VersionCreate, VersionUpdate
+
+def validate_version_number(version_number: str) -> bool:
+    """
+    Validate version number format (e.g., 1.0.0, 2.1.3)
+    
+    Args:
+        version_number: Version number string to validate
+        
+    Returns:
+        bool: True if version format is valid, False otherwise
+    """
+    pattern = r'^\d+\.\d+\.\d+$'
+    return bool(re.match(pattern, version_number))
+
+def parse_version_components(version_number: str) -> Dict[str, int]:
+    """
+    Parse version number into major, minor and patch components
+    
+    Args:
+        version_number: Version number string (e.g. '1.2.3')
+        
+    Returns:
+        Dict containing major, minor and patch numbers
+    """
+    major, minor, patch = version_number.split('.')
+    return {
+        'major': int(major),
+        'minor': int(minor),
+        'patch': int(patch)
+    }
+
+def compare_versions(version1: str, version2: str) -> int:
+    """
+    Compare two version numbers
+    
+    Args:
+        version1: First version number
+        version2: Second version number
+        
+    Returns:
+        1 if version1 > version2
+        -1 if version1 < version2
+        0 if version1 == version2
+    """
+    v1_components = parse_version_components(version1)
+    v2_components = parse_version_components(version2)
+    
+    for component in ['major', 'minor', 'patch']:
+        if v1_components[component] > v2_components[component]:
+            return 1
+        elif v1_components[component] < v2_components[component]:
+            return -1
+    return 0
+
+def get_latest_version(db: Session) -> Optional[Version]:
+    """
+    Get the latest version from database
+    
+    Args:
+        db: Database session
+        
+    Returns:
+        Latest Version object if exists, None otherwise
+    """
+    return db.query(Version).order_by(Version.version_number.desc()).first()
+
+def create_version_safely(db: Session, version_data: VersionCreate) -> Union[Version, Dict[str, str]]:
+    """
+    Create a new version with validation and error handling
+    
+    Args:
+        db: Database session
+        version_data: Version data for creation
+        
+    Returns:
+        Version object if created successfully, error dict otherwise
+    """
+    if not validate_version_number(version_data.version_number):
+        return {"error": "Invalid version number format"}
+    
+    existing_version = db.query(Version).filter(
+        Version.version_number == version_data.version_number
+    ).first()
+    
+    if existing_version:
+        return {"error": "Version already exists"}
+        
+    db_version = Version(
+        version_number=version_data.version_number,
+        description=version_data.description
+    )
+    
+    db.add(db_version)
+    db.commit()
+    db.refresh(db_version)
+    
+    return db_version
+
+def increment_version(current_version: str, increment_type: str = 'patch') -> str:
+    """
+    Increment version number based on semantic versioning
+    
+    Args:
+        current_version: Current version number
+        increment_type: Type of increment ('major', 'minor', or 'patch')
+        
+    Returns:
+        New version number
+    """
+    components = parse_version_components(current_version)
+    
+    if increment_type == 'major':
+        components['major'] += 1
+        components['minor'] = 0
+        components['patch'] = 0
+    elif increment_type == 'minor':
+        components['minor'] += 1
+        components['patch'] = 0
+    else:  # patch
+        components['patch'] += 1
+        
+    return f"{components['major']}.{components['minor']}.{components['patch']}"